Home Node.js Music Playlist Manager with Node.js and Express.js

Music Playlist Manager with Node.js and Express.js

Subscription Management System with NodeJS and ExpressJS

In this article, we’ll walk through the step-by-step process of creating a Music Playlist Manager with NodeJS and ExpressJS. This application will provide users with the ability to register, log in, create playlists, add tracks to playlists, update playlists, delete playlists, and manage their user profile. We’ll also implement authentication using JWT (JSON Web Tokens) to secure the endpoints.

Prerequisites:

Approach to Create Music Playlist Manager with Node.js and Express.js

  • Identify key features like user User authentication and authorization, Music Playlist Manager (CRUD operations), User playlist management, and Secure APIs using JWT (JSON Web Tokens).
  • Install Node.js, npm, ExpressJS, and other project dependencies.
  • Create a new project directory and initialize it.
  • Ensure MongoDB is installed and running locally or use a cloud-based MongoDB instance. Create a database for your Music Playlist Manager.
  • Create Mongoose models to represent User, Playlist, and Track entities.
  • Implement Authentication, Authorization Middleware, Music Playlist Manager.

Steps to Create the NodeJS App and Installing Module:

Step 1: Create a NodeJS project using the following command.

npm init -y

Step 2: Install Express.js and other necessary dependencies.

npm install express mongoose jsonwebtoken bcryptjs body-parser express-validator dotenv

Step 3: Create folders for different parts of the application such as models, routes, and middleware. Inside each folder, create corresponding files for different components of the application.

Step 4: Set up a MongoDB database either locally or using a cloud-based service like MongoDB Atlas. Define Mongoose models for the data entities such as User, PlayList, Track.

Project Structure

Project Folder Structure

The updated dependencies in package.json file will look like:

"dependencies": {
        "bcryptjs": "^2.4.3",
        "body-parser": "^1.19.0",
        "dotenv": "^10.0.0",
        "express": "^4.17.1",
        "express-validator": "^7.0.1",
        "jsonwebtoken": "^8.5.1",
        "mongoose": "^6.1.3",
        "nodemon": "^3.1.0"
    }

Example: Below is an example of Travel Planning App with NodeJS and ExpressJS.

JavaScript 
// db.js
const mongoose = require('mongoose');
require('dotenv').config();

const connectDB = async () => {
    try {
        await mongoose.connect(process.env.DB_URI);
        console.log('MongoDB connected');
    } catch (err) {
        console.error('MongoDB connection error:', err.message);
        process.exit(1);
    }
};

module.exports = connectDB;
JavaScript 
// jwt.js
require('dotenv').config();

module.exports = {
    jwtSecret: process.env.JWT_SECRET,
    jwtExpiration: '10h', // Token expiration time
};
JavaScript 
// adminController.js
const User = require('../models/User');
const Playlist = require('../models/Playlist');

exports.getAllUsers = async (req, res) => {
    try {
        const users = await User.find();
        res.status(200).json(users);
    } catch (err) {
        res.status(500).json({ error: 'Server error' });
    }
};

exports.deleteUser = async (req, res) => {
    const { userId } = req.params;
    try {
        const user = await User.findByIdAndDelete(userId);
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        res.status(200).json({ message: 'User deleted' });
    } catch (err) {
        res.status(500).json({ error: 'Server error' });
    }
};

exports.getAllPlaylists = async (req, res) => {
    try {
        const playlists = await Playlist.find();
        res.status(200).json(playlists);
    } catch (err) {
        res.status(500).json({ error: 'Server error' });
    }
};

exports.deletePlaylist = async (req, res) => {
    const { playlistId } = req.params;
    try {
        const playlist = await Playlist.findByIdAndDelete(playlistId);
        if (!playlist) {
            return res.status(404).json({ error: 'Playlist not found' });
        }
        res.status(200).json({ message: 'Playlist deleted' });
    } catch (err) {
        res.status(500).json({ error: 'Server error' });
    }
};
JavaScript 
// authController.js
const User = require('../models/User');
const jwt = require('jsonwebtoken');
const { jwtSecret, jwtExpiration } = require('../config/jwt');

exports.register = async (req, res) => {
    const { username, email, password } = req.body;
    try {
        let user = await User.findOne({ email });
        if (user) {
            return res.status(400).json({ error: 'User already exists' });
        }
        user = new User({ username, email, password });
        await user.save();
        const payload = { userId: user._id };
        const token = jwt.sign(payload, jwtSecret, { expiresIn: jwtExpiration });
        res.status(201).json({ token });
    } catch (err) {
        res.status(500).json({ error: 'Server error' });
    }
};

exports.login = async (req, res) => {
    const { email, password } = req.body;
    try {
        const user = await User.findOne({ email });
        if (!user || !(await user.comparePassword(password))) {
            return res.status(400).json({ error: 'Invalid credentials' });
        }
        const payload = { userId: user._id };
        const token = jwt.sign(payload, jwtSecret, { expiresIn: jwtExpiration });
        res.status(200).json({ token });
    } catch (err) {
        res.status(500).json({ error: 'Server error' });
    }
};
JavaScript 
// playlistController.js
const Playlist = require('../models/Playlist');

exports.createPlaylist = async (req, res) => {
    const { name, description } = req.body;
    try {
        const playlist = new Playlist({ name, description, user: req.user.userId });
        await playlist.save();
        res.status(201).json(playlist);
    } catch (err) {
        res.status(500).json({ error: 'Server error' });
    }
};

exports.getPlaylists = async (req, res) => {
    try {
        const playlists = await Playlist.find({ user: req.user.userId });
        res.status(200).json(playlists);
    } catch (err) {
        res.status(500).json({ error: 'Server error' });
    }
};

exports.updatePlaylist = async (req, res) => {
    const { id } = req.params;
    const { name, description } = req.body;
    try {
        const playlist = await Playlist.findByIdAndUpdate(
            id,
            { name, description },
            { new: true }
        );
        if (!playlist) {
            return res.status(404).json({ error: 'Playlist not found' });
        }
        res.status(200).json(playlist);
    } catch (err) {
        res.status(500).json({ error: 'Server error' });
    }
};

exports.deletePlaylist = async (req, res) => {
    const { id } = req.params;
    try {
        const playlist = await Playlist.findByIdAndDelete(id);
        if (!playlist) {
            return res.status(404).json({ error: 'Playlist not found' });
        }
        res.status(200).json({ message: 'Playlist deleted' });
    } catch (err) {
        res.status(500).json({ error: 'Server error' });
    }
};
JavaScript 
// trackController.js
const Playlist = require('../models/Playlist');
const Track = require('../models/Track');

exports.addTrack = async (req, res) => {
    const { playlistId } = req.params; // Correctly destructure playlistId from params
    const track = req.body;
    try {
        const playlist = await Playlist.findById(playlistId);
        if (!playlist) {
            return res.status(404).json({ error: 'Playlist not found' });
        }
        const newTrack = new Track(track);
        playlist.tracks.push(newTrack);
        await newTrack.save(); // Ensure the new track is saved to the database
        await playlist.save();
        res.status(201).json(newTrack);
    } catch (err) {
        res.status(500).json({ error: 'Server error' });
    }
};

exports.removeTrack = async (req, res) => {
    const { playlistId, trackId } = req.params;
    try {
        const playlist = await Playlist.findById(playlistId);
        if (!playlist) {
            return res.status(404).json({ error: 'Playlist not found' });
        }
        const trackIndex = playlist.tracks.findIndex(track => track._id.equals(trackId));
        if (trackIndex === -1) {
            return res.status(404).json({ error: 'Track not found' });
        }
        playlist.tracks.splice(trackIndex, 1);
        await playlist.save();
        res.status(200).json({ message: 'Track removed' });
    } catch (err) {
        res.status(500).json({ error: 'Server error' });
    }
};

exports.getTracks = async (req, res) => {
    const { playlistId } = req.params;
    try {
        const playlist = await Playlist.findById(playlistId).populate('tracks');
        if (!playlist) {
            return res.status(404).json({ error: 'Playlist not found' });
        }
        res.status(200).json(playlist.tracks);
    } catch (err) {
        res.status(500).json({ error: 'Server error' });
    }
};
JavaScript 
// userController.js
const User = require('../models/User');

exports.getUserProfile = async (req, res) => {
    try {
        const user = await User.findById(req.user.userId);
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        res.status(200).json(user);
    } catch (err) {
        res.status(500).json({ error: 'Server error' });
    }
};

exports.updateUserProfile = async (req, res) => {
    const { username, email } = req.body;
    try {
        const user = await User.findByIdAndUpdate(
            req.user.userId,
            { username, email },
            { new: true }
        );
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        res.status(200).json(user);
    } catch (err) {
        res.status(500).json({ error: 'Server error' });
    }
};

exports.deleteUserProfile = async (req, res) => {
    try {
        const user = await User.findByIdAndDelete(req.user.userId);
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        res.status(200).json({ message: 'User deleted' });
    } catch (err) {
        res.status(500).json({ error: 'Server error' });
    }
};
JavaScript 
// authMiddleware.js
const jwt = require('jsonwebtoken');
const { jwtSecret } = require('../config/jwt');

const authMiddleware = (req, res, next) => {
    const token = req.header('Authorization')?.replace('Bearer ', '');
    if (!token) {
        return res.status(401).json({ error: 'Access denied, no token provided.' });
    }

    try {
        const decoded = jwt.verify(token, jwtSecret);
        req.user = decoded;
        next();
    } catch (err) {
        res.status(400).json({ error: 'Invalid token.' });
    }
};

module.exports = authMiddleware;
JavaScript 
// errorMiddleware.js
const errorMiddleware = (err, req, res, next) => {
    console.error(err.stack);
    res.status(500).json({
        message: 'An unexpected error occurred',
        error: err.message
    });
};

module.exports = errorMiddleware;
JavaScript 
// validationMiddleware.js
const { validationResult } = require('express-validator');

const validationMiddleware = (req, res, next) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(400).json({ errors: errors.array() });
    }
    next();
};

module.exports = validationMiddleware;
JavaScript 
// Playlist.js
const mongoose = require('mongoose');

const playlistSchema = new mongoose.Schema({
    name: { type: String, required: true },
    description: { type: String, default: '' },
    user: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
    tracks: [{ type: mongoose.Schema.Types.ObjectId, ref: 'Track' }]
}, { timestamps: true });

const Playlist = mongoose.model('Playlist', playlistSchema);

module.exports = Playlist;
JavaScript 
// Track.js
const mongoose = require('mongoose');

const trackSchema = new mongoose.Schema({
    title: { type: String, required: true },
    artist: { type: String, required: true },
    album: { type: String, default: '' },
    duration: { type: Number, required: true },
    genre: { type: String, default: '' },
    url: { type: String, required: true }
}, { timestamps: true });

const Track = mongoose.model('Track', trackSchema);

module.exports = Track;
JavaScript 
// User.js
// User.js
// User.js
const mongoose = require('mongoose');
const bcrypt = require('bcryptjs');

const userSchema = new mongoose.Schema({
    username: { type: String, required: true, unique: true },
    email: { type: String, required: true, unique: true },
    password: { type: String, required: true },
    profilePicture: { type: String, default: '' },
}, { timestamps: true });

userSchema.pre('save', async function (next) {
    if (!this.isModified('password')) {
        return next();
    }
    const salt = await bcrypt.genSalt(10);
    this.password = await bcrypt.hash(this.password, salt);
    next();
});

userSchema.methods.comparePassword = async function (password) {
    return bcrypt.compare(password, this.password);
};

const User = mongoose.model('User', userSchema);

module.exports = User;
JavaScript 
// adminRoutes.js
const express = require('express');
const authMiddleware = require('../middlewares/authMiddleware');
const adminController = require('../controllers/adminController');

const router = express.Router();

// Protected routes, require authentication
router.use(authMiddleware);

// GET /api/admin/users
router.get('/users', adminController.getAllUsers);

// DELETE /api/admin/users/:userId
router.delete('/users/:userId', adminController.deleteUser);

// GET /api/admin/playlists
router.get('/playlists', adminController.getAllPlaylists);

// DELETE /api/admin/playlists/:playlistId
router.delete('/playlists/:playlistId', adminController.deletePlaylist);

module.exports = router;
JavaScript 
// authRoutes.js
const express = require('express');
const { body } = require('express-validator');
const authController = require('../controllers/authController');
const validationMiddleware = require('../middlewares/validationMiddleware');

const router = express.Router();

// POST /api/auth/register
router.post(
    '/register',
    [
        body('username').notEmpty().withMessage('Username is required'),
        body('email').isEmail().withMessage('Valid email is required'),
        body('password').isLength({ min: 6 }).withMessage('Password must be at least 6 characters long')
    ],
    validationMiddleware,
    authController.register
);

// POST /api/auth/login
router.post(
    '/login',
    [
        body('email').isEmail().withMessage('Valid email is required'),
        body('password').notEmpty().withMessage('Password is required')
    ],
    validationMiddleware,
    authController.login
);

module.exports = router;
JavaScript 
// playlistRoutes.js
const express = require('express');
const authMiddleware = require('../middlewares/authMiddleware');
const playlistController = require('../controllers/playlistController');

const router = express.Router();

// Protected routes, require authentication
router.use(authMiddleware);

// POST /api/playlists
router.post('/', playlistController.createPlaylist);

// GET /api/playlists
router.get('/', playlistController.getPlaylists);

// PUT /api/playlists/:id
router.put('/:id', playlistController.updatePlaylist);

// DELETE /api/playlists/:id
router.delete('/:id', playlistController.deletePlaylist);

module.exports = router;
JavaScript 
// trackRoutes.js
const express = require('express');
const authMiddleware = require('../middlewares/authMiddleware');
const trackController = require('../controllers/trackController');

const router = express.Router();

// Protected routes, require authentication
router.use(authMiddleware);

// POST /api/tracks/:playlistId
router.post('/:playlistId', trackController.addTrack);

// DELETE /api/tracks/:playlistId/:trackId
router.delete('/:playlistId/:trackId', trackController.removeTrack);

// GET /api/tracks/:playlistId
router.get('/:playlistId', trackController.getTracks);

module.exports = router;
JavaScript 
// userRoutes.js
const express = require('express');
const authMiddleware = require('../middlewares/authMiddleware');
const userController = require('../controllers/userController');

const router = express.Router();

// Protected routes, require authentication
router.use(authMiddleware);

// GET /api/users/profile
router.get('/profile', userController.getUserProfile);

// PUT /api/users/profile
router.put('/profile', userController.updateUserProfile);

// DELETE /api/users/profile
router.delete('/profile', userController.deleteUserProfile);

module.exports = router;
JavaScript 
// userRoutes.js
const express = require('express');
const authMiddleware = require('../middlewares/authMiddleware');
const userController = require('../controllers/userController');

const router = express.Router();

// Protected routes, require authentication
router.use(authMiddleware);

// GET /api/users/profile
router.get('/profile', userController.getUserProfile);

// PUT /api/users/profile
router.put('/profile', userController.updateUserProfile);

// DELETE /api/users/profile
router.delete('/profile', userController.deleteUserProfile);

module.exports = router;
JavaScript 
// notificationService.js
// Import necessary modules
const NotificationService = require('./notificationService');

// Function to send notification
exports.sendNotification = async (userId, message) => {
    try {
        // Example: Send notification using a hypothetical notification service
        await NotificationService.send(userId, message);
        console.log(`Notification sent to user ${userId}: ${message}`);
    } catch (error) {
        throw new Error('Failed to send notification');
    }
};
JavaScript 
// playlistService.js
// Import necessary modules/models
const Playlist = require('../models/Playlist');

// Function to create a new playlist
exports.createPlaylist = async (name, description, userId) => {
    try {
        const playlist = new Playlist({ name, description, user: userId });
        await playlist.save();
        return playlist;
    } catch (error) {
        throw new Error('Failed to create playlist');
    }
};

// Function to get all playlists of a user
exports.getPlaylistsByUser = async (userId) => {
    try {
        const playlists = await Playlist.find({ user: userId });
        return playlists;
    } catch (error) {
        throw new Error('Failed to get playlists');
    }
};

// Function to update a playlist
exports.updatePlaylist = async (playlistId, name, description) => {
    try {
        const playlist = await Playlist.findByIdAndUpdate(
            playlistId,
            { name, description },
            { new: true }
        );
        return playlist;
    } catch (error) {
        throw new Error('Failed to update playlist');
    }
};

// Function to delete a playlist
exports.deletePlaylist = async (playlistId) => {
    try {
        const playlist = await Playlist.findByIdAndDelete(playlistId);
        return playlist;
    } catch (error) {
        throw new Error('Failed to delete playlist');
    }
};
JavaScript 
// trackService.js
// Import necessary modules/models
const Playlist = require('../models/Playlist');
const Track = require('../models/Track');

// Function to add a track to a playlist
exports.addTrackToPlaylist = async (playlistId, trackData) => {
    try {
        const playlist = await Playlist.findById(playlistId);
        if (!playlist) {
            throw new Error('Playlist not found');
        }
        const newTrack = new Track(trackData);
        playlist.tracks.push(newTrack);
        await playlist.save();
        return newTrack;
    } catch (error) {
        throw new Error('Failed to add track to playlist');
    }
};

// Function to remove a track from a playlist
exports.removeTrackFromPlaylist = async (playlistId, trackId) => {
    try {
        const playlist = await Playlist.findById(playlistId);
        if (!playlist) {
            throw new Error('Playlist not found');
        }
        playlist.tracks = playlist.tracks.filter(t => t._id != trackId);
        await playlist.save();
    } catch (error) {
        throw new Error('Failed to remove track from playlist');
    }
};

// Function to get all tracks of a playlist
exports.getTracksByPlaylist = async (playlistId) => {
    try {
        const playlist = await Playlist.findById(playlistId).populate('tracks');
        if (!playlist) {
            throw new Error('Playlist not found');
        }
        return playlist.tracks;
    } catch (error) {
        throw new Error('Failed to get tracks from playlist');
    }
};
JavaScript 
// userService.js
// Import necessary modules/models
const User = require('../models/User');

// Function to get user profile
exports.getUserProfile = async (userId) => {
    try {
        const user = await User.findById(userId);
        if (!user) {
            throw new Error('User not found');
        }
        return user;
    } catch (error) {
        throw new Error('Failed to get user profile');
    }
};

// Function to update user profile
exports.updateUserProfile = async (userId, username, email) => {
    try {
        const user = await User.findByIdAndUpdate(
            userId,
            { username, email },
            { new: true }
        );
        if (!user) {
            throw new Error('User not found');
        }
        return user;
    } catch (error) {
        throw new Error('Failed to update user profile');
    }
};

// Function to delete user profile
exports.deleteUserProfile = async (userId) => {
    try {
        const user = await User.findByIdAndDelete(userId);
        if (!user) {
            throw new Error('User not found');
        }
        return user;
    } catch (error) {
        throw new Error('Failed to delete user profile');
    }
};
JavaScript 
// apiUtils.js
// Function to fetch data from an external API
exports.fetchDataFromAPI = async (url) => {
    try {
        const response = await fetch(url);
        if (!response.ok) {
            throw new Error('Failed to fetch data from API');
        }
        const data = await response.json();
        return data;
    } catch (error) {
        throw new Error('Failed to fetch data from API');
    }
};
JavaScript 
// dbUtils.js
// Import necessary modules/models
const User = require('../models/User');
const Playlist = require('../models/Playlist');
const Track = require('../models/Track');

// Function to find a user by ID
exports.findUserById = async (userId) => {
    try {
        const user = await User.findById(userId);
        return user;
    } catch (error) {
        throw new Error('Failed to find user by ID');
    }
};

// Function to find a playlist by ID
exports.findPlaylistById = async (playlistId) => {
    try {
        const playlist = await Playlist.findById(playlistId);
        return playlist;
    } catch (error) {
        throw new Error('Failed to find playlist by ID');
    }
};

// Function to find a track by ID
exports.findTrackById = async (trackId) => {
    try {
        const track = await Track.findById(trackId);
        return track;
    } catch (error) {
        throw new Error('Failed to find track by ID');
    }
};
JavaScript 
// jwtUtils.js
const jwt = require('jsonwebtoken');
const { jwtSecret, jwtExpiration } = require('../config/jwt');

// Function to generate JWT token
exports.generateToken = (userId) => {
    const payload = { userId };
    const token = jwt.sign(payload, jwtSecret, { expiresIn: jwtExpiration });
    return token;
};

// Function to verify JWT token
exports.verifyToken = (token) => {
    try {
        const decoded = jwt.verify(token, jwtSecret);
        return decoded;
    } catch (error) {
        throw new Error('Failed to verify token');
    }
};
JavaScript 
// app.js
// app.js
// app.js
const express = require('express');
const bodyParser = require('body-parser');
const connectDB = require('./config/db');
const authRoutes = require('./routes/authRoutes');
const playlistRoutes = require('./routes/playlistRoutes');
const trackRoutes = require('./routes/trackRoutes');
const userRoutes = require('./routes/userRoutes');
const adminRoutes = require('./routes/adminRoutes');
const errorMiddleware = require('./middlewares/errorMiddleware');

// Connect to MongoDB
connectDB();

const app = express();

app.use(bodyParser.json());

app.use('/api/auth', authRoutes);
app.use('/api/playlists', playlistRoutes);
app.use('/api/tracks', trackRoutes);
app.use('/api/users', userRoutes);
app.use('/api/admin', adminRoutes);

app.use(errorMiddleware);

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`Server is running on port ${PORT}`);
});

Start your server using the following command:

node app.js

Output:




Tags:
#nodejs #Express.js #Node.js #Project #Web Technologies

Subscription Management System with NodeJS and ExpressJS

Contact Us

Categories
Learn the most popular programming languages in the world.