Forem: Shamsuddeen Omacy

Implementing the Repository Design Pattern in Node.js & Express: A Complete Guide

Shamsuddeen Omacy — Sat, 25 Oct 2025 17:56:46 +0000

What's Covered:

Core Concepts:

Clear explanation of what the Repository Pattern is
Importance rating: 9/10 with detailed justification
Complete separation of concerns across layers

Full Implementation:

Model Layer - Mongoose schema with validation
Repository Layer - All CRUD operations centralized
Service Layer - Business logic separate from data access
Controller Layer - HTTP request/response handling
Routes - Clean API endpoint definitions

Introduction

The Repository Design Pattern is a crucial architectural pattern that acts as a bridge between your business logic and data access layer. In this comprehensive tutorial, we'll build a Task Management API using Node.js and Express to demonstrate how this pattern can transform your code quality and maintainability.

What is the Repository Pattern?

The Repository Pattern is a design pattern that creates an abstraction layer between the data access logic and the business logic of an application, thereby separating these two components. Think of it as a mediator that handles all communication with your data source (database, API, file system, etc.).

Key Concepts:

Abstraction: Hides the complexity of data access operations
Separation of Concerns: Business logic doesn't know about database implementation
Testability: Easy to mock repositories for unit testing
Flexibility: Switch databases without changing business logic

Importance Scale: 9/10

Why this high rating?
✅ Maintainability: Changes to data access logic are centralized.
✅ Testability: Mock repositories easily for unit tests
✅ Flexibility: Swap MongoDB for PostgreSQL without touching business logic
✅ DRY Principle: Eliminate repetitive database queries
✅ Team Collaboration: Clear boundaries between layers
✅ Error Handling: Centralized data access error management

Project Setup

Let's start by setting up our Task Management API:

mkdir taska
cd taska
npm init -y

Install dependencies:

npm install express mongoose dotenv
npm install -D nodemon

Project structure:

taska/
├── src/
│   ├── models/
│   │   └── task.model.js
│   ├── repositories/
│   │   └── task.repository.js
│   ├── services/
│   │   └── task.service.js
│   ├── controllers/
│   │   └── task.controller.js
│   ├── routes/
│   │   └── task.routes.js
│   └── app.js
├── .env
├── server.js
└── package.json

Step 1: Create the Task Model

The model defines the data structure.
src/models/task.model.js


const mongoose = require('mongoose');

const taskSchema = new mongoose.Schema({
  title: {
    type: String,
    required: [true, 'Task title is required'],
    trim: true,
    maxlength: [100, 'Title cannot exceed 100 characters']
  },
  description: {
    type: String,
    trim: true,
    maxlength: [500, 'Description cannot exceed 500 characters']
  },
  status: {
    type: String,
    enum: ['pending', 'in-progress', 'completed'],
    default: 'pending'
  },
  priority: {
    type: String,
    enum: ['low', 'medium', 'high'],
    default: 'medium'
  },
  dueDate: {
    type: Date
  },
  createdAt: {
    type: Date,
    default: Date.now
  },
  updatedAt: {
    type: Date,
    default: Date.now
  }
});

taskSchema.pre('save', function(next) {
  this.updatedAt = Date.now();
  next();
});

module.exports = mongoose.model('Task', taskSchema);

Step 2: Implement the Repository Layer

This is where the magic happens! The repository handles all database operations.
src/repositories/task.repository.js


const Task = require('../models/task.model');

class TaskRepository {

  // CREATE - Add a new task
  async create(taskData) {
    try {
      const task = new Task(taskData);
      return await task.save();
    } catch (error) {
      throw new Error(`Error creating task: ${error.message}`);
    }
  }

  // READ - Get all tasks with optional filtering
  async findAll(filters = {}) {
    try {
      const query = {};

      // Apply filters if provided
      if (filters.status) query.status = filters.status;
      if (filters.priority) query.priority = filters.priority;

      return await Task.find(query).sort({ createdAt: -1 });
    } catch (error) {
      throw new Error(`Error fetching tasks: ${error.message}`);
    }
  }

  // READ - Get a single task by ID
  async findById(taskId) {
    try {
      const task = await Task.findById(taskId);
      if (!task) {
        throw new Error('Task not found');
      }
      return task;
    } catch (error) {
      throw new Error(`Error fetching task: ${error.message}`);
    }
  }

  // READ - Find tasks by status
  async findByStatus(status) {
    try {
      return await Task.find({ status }).sort({ createdAt: -1 });
    } catch (error) {
      throw new Error(`Error fetching tasks by status: ${error.message}`);
    }
  }

  // UPDATE - Update a task by ID
  async update(taskId, updateData) {
    try {
      const task = await Task.findByIdAndUpdate(
        taskId,
        { ...updateData, updatedAt: Date.now() },
        { new: true, runValidators: true }
      );

      if (!task) {
        throw new Error('Task not found');
      }

      return task;
    } catch (error) {
      throw new Error(`Error updating task: ${error.message}`);
    }
  }

  // DELETE - Remove a task by ID
  async delete(taskId) {
    try {
      const task = await Task.findByIdAndDelete(taskId);

      if (!task) {
        throw new Error('Task not found');
      }

      return task;
    } catch (error) {
      throw new Error(`Error deleting task: ${error.message}`);
    }
  }

  // Additional utility methods
  async count(filters = {}) {
    try {
      return await Task.countDocuments(filters);
    } catch (error) {
      throw new Error(`Error counting tasks: ${error.message}`);
    }
  }

  async deleteAll() {
    try {
      return await Task.deleteMany({});
    } catch (error) {
      throw new Error(`Error deleting all tasks: ${error.message}`);
    }
  }
}

module.exports = new TaskRepository();

Step 3: Create the Service Layer

The service layer contains business logic and uses the repository.
src/services/task.service.js


const taskRepository = require('../repositories/task.repository');

class TaskService {

  async createTask(taskData) {
    // Business logic: validate due date
    if (taskData.dueDate && new Date(taskData.dueDate) < new Date()) {
      throw new Error('Due date cannot be in the past');
    }

    return await taskRepository.create(taskData);
  }

  async getAllTasks(filters) {
    return await taskRepository.findAll(filters);
  }

  async getTaskById(taskId) {
    return await taskRepository.findById(taskId);
  }

  async updateTask(taskId, updateData) {
    // Business logic: prevent invalid status transitions
    if (updateData.status === 'completed') {
      const task = await taskRepository.findById(taskId);
      if (task.status === 'pending') {
        throw new Error('Cannot mark pending task as completed. Move to in-progress first.');
      }
    }

    return await taskRepository.update(taskId, updateData);
  }

  async deleteTask(taskId) {
    return await taskRepository.delete(taskId);
  }

  async getTaskStats() {
    const total = await taskRepository.count();
    const pending = await taskRepository.count({ status: 'pending' });
    const inProgress = await taskRepository.count({ status: 'in-progress' });
    const completed = await taskRepository.count({ status: 'completed' });

    return {
      total,
      pending,
      inProgress,
      completed
    };
  }
}

module.exports = new TaskService();

Step 4: Build the Controller Layer

Controllers handle HTTP requests and responses.
src/controllers/task.controller.js

const taskService = require('../services/task.service');

class TaskController {

  // CREATE a new task
  async create(req, res) {
    try {
      const task = await taskService.createTask(req.body);
      res.status(201).json({
        success: true,
        message: 'Task created successfully',
        data: task
      });
    } catch (error) {
      res.status(400).json({
        success: false,
        message: error.message
      });
    }
  }

  // READ all tasks
  async getAll(req, res) {
    try {
      const { status, priority } = req.query;
      const filters = {};

      if (status) filters.status = status;
      if (priority) filters.priority = priority;

      const tasks = await taskService.getAllTasks(filters);
      res.status(200).json({
        success: true,
        count: tasks.length,
        data: tasks
      });
    } catch (error) {
      res.status(500).json({
        success: false,
        message: error.message
      });
    }
  }

  // READ a single task
  async getById(req, res) {
    try {
      const task = await taskService.getTaskById(req.params.id);
      res.status(200).json({
        success: true,
        data: task
      });
    } catch (error) {
      res.status(404).json({
        success: false,
        message: error.message
      });
    }
  }

  // UPDATE a task
  async update(req, res) {
    try {
      const task = await taskService.updateTask(req.params.id, req.body);
      res.status(200).json({
        success: true,
        message: 'Task updated successfully',
        data: task
      });
    } catch (error) {
      res.status(400).json({
        success: false,
        message: error.message
      });
    }
  }

  // DELETE a task
  async delete(req, res) {
    try {
      await taskService.deleteTask(req.params.id);
      res.status(200).json({
        success: true,
        message: 'Task deleted successfully'
      });
    } catch (error) {
      res.status(404).json({
        success: false,
        message: error.message
      });
    }
  }

  // Get task statistics
  async getStats(req, res) {
    try {
      const stats = await taskService.getTaskStats();
      res.status(200).json({
        success: true,
        data: stats
      });
    } catch (error) {
      res.status(500).json({
        success: false,
        message: error.message
      });
    }
  }
}

module.exports = new TaskController();

Step 5: Define Routes

src/routes/task.routes.js

const express = require('express');
const router = express.Router();
const taskController = require('../controllers/task.controller');

// CRUD Routes
router.post('/', taskController.create);
router.get('/', taskController.getAll);
router.get('/stats', taskController.getStats);
router.get('/:id', taskController.getById);
router.put('/:id', taskController.update);
router.delete('/:id', taskController.delete);

module.exports = router;

Step 6: Set Up Express App

src/app.js

const express = require('express');
const taskRoutes = require('./routes/task.routes');

const app = express();

// Middleware
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// Routes
app.use('/api/tasks', taskRoutes);

// Health check
app.get('/health', (req, res) => {
  res.status(200).json({ status: 'OK', message: 'Server is running' });
});

// Error handling middleware
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({
    success: false,
    message: 'Something went wrong!',
    error: err.message
  });
});

module.exports = app;

Step 7: Create Server Entry Point

server.js

const mongoose = require('mongoose');
const app = require('./src/app');
require('dotenv').config();

const PORT = process.env.PORT || 3000;
const MONGODB_URI = process.env.MONGODB_URI || 'mongodb://localhost:27017/taskmanager';

mongoose.connect(MONGODB_URI)
  .then(() => {
    console.log('✅ Connected to MongoDB');
    app.listen(PORT, () => {
      console.log(`🚀 Server is running on port ${PORT}`);
    });
  })
  .catch((error) => {
    console.error('❌ MongoDB connection error:', error);
    process.exit(1);
  });

Environment Configuration
.env

PORT=3000
MONGODB_URI=mongodb://localhost:27017/taskmanager
package.json (add scripts)
{
  "scripts": {
    "start": "node server.js",
    "dev": "nodemon server.js"
  }
}

Benefits Demonstrated

Easy Database Switching Want to switch from MongoDB to PostgreSQL? Just create a new repository: task.repository.postgres.js

class TaskRepositoryPostgres {
  async create(taskData) {
    // PostgreSQL implementation
    return await pool.query('INSERT INTO tasks...');
  }
  // ... other methods
}

Your service and controller layers remain unchanged!

2. Simplified Testing

Mock the repository for unit tests:

const mockRepository = {
  create: jest.fn(),
  findAll: jest.fn(),
  findById: jest.fn(),
  update: jest.fn(),
  delete: jest.fn()
};

3. Centralized Data Logic

All database queries are in one place. Need to add caching? Update the repository only.

4. Clear Separation

Model: Data structure
Repository: Data access
Service: Business logic
Controller: HTTP handling
Routes: Endpoint definitions

Advanced Patterns

Generic Repository
Create a base repository for common operations:

class BaseRepository {
  constructor(model) {
    this.model = model;
  }
  async create(data) {
      return await this.model.create(data);
    }
    async findAll(filters = {}) {
      return await this.model.find(filters);
    }
    async findById(id) {
      return await this.model.findById(id);
    }
    async update(id, data) {
      return await this.model.findByIdAndUpdate(id, data, { new: true });
    }
    async delete(id) {
      return await this.model.findByIdAndDelete(id);
    }
  }
  // Extend for specific repositories
  class TaskRepository extends BaseRepository {
    constructor() {
      super(Task);
    }
    // Add task-specific methods
    async findOverdueTasks() {
      return await this.model.find({
        dueDate: { $lt: new Date() },
        status: { $ne: 'completed' }
      });
    }
}

Conclusion

The Repository Pattern is a powerful tool for building maintainable, testable, and scalable Node.js applications. By separating data access logic from business logic, you create a clean architecture that's easy to understand, modify, and extend.

Key Takeaways:

The Repository Pattern adds a layer between business logic and data access

Makes code more testable and maintainable
Enables easy database switching without affecting business logic
Promotes clean code architecture and separation of concerns
Scales well with team size and project complexity

Start implementing this pattern in your next Node.js project and experience the difference in code quality and maintainability!

Here is the link to the complete repo on GitHub

Bring Your Integration (BYI): Building Connected Ecosystems for Better User Experiences

Shamsuddeen Omacy — Thu, 23 Jan 2025 01:58:23 +0000

In today’s fast-paced, tech-driven world, no platform is an island. Businesses, developers, and users alike demand seamless connections between tools and systems to unlock their full potential. Enter Bring Your Integration (BYI): a framework designed to break down silos, promote interoperability, and empower ecosystems to grow stronger through collaboration.

Let’s dive into what makes BYI an essential approach in industries where flexibility and connection aren’t just nice-to-have—they’re non-negotiable.

What is BYI?

At its core, BYI invites businesses, platforms, and developers to integrate their systems into a pre-existing ecosystem. Think of it as building bridges between tools that once operated in isolation, creating a symphony of interconnected functionality.

BYI thrives in industries like FinTech, EduTech, and HealthTech, where innovation is fueled by collaboration. It’s a movement that prioritizes making systems not just work—but work together.

How BYI Works: Building Blocks of Connection

BYI operates on key pillars that make integrations smoother, faster, and more impactful.

1. Open APIs: The Gateway to Connectivity

Open APIs are the backbone of BYI. By providing clear, well-documented APIs, businesses give developers the tools to plug into their systems effortlessly. In FinTech, for example, this could mean enabling merchants to integrate payment gateways or fraud detection tools into their platforms.

2. SDKs: Simplifying Complexity for Developers

For developers building advanced functionalities, Software Development Kits (SDKs) are a lifesaver. They offer pre-built code, libraries, and resources that make integration faster and more efficient. Whether it’s enabling secure payment processing or real-time analytics, SDKs reduce the guesswork.

3. Plug-and-Play Solutions: Power for Everyone

Not every business has a technical team. That’s where BYI’s plug-and-play modules come in. Think widgets, plugins, or ready-to-use tools that require minimal setup, allowing even non-developers to join the ecosystem.

4. Customizable Workflows: Tailored for Every User

No two businesses are alike. BYI frameworks enable users to adapt integrations to their specific workflows, creating personalized solutions that feel like they were built just for them.

5. Marketplace of Possibilities: Third-Party Partnerships

BYI fosters collaboration by inviting third-party vendors to bring their tools into the ecosystem. This creates a marketplace of integrations that benefits everyone—businesses, developers, and users alike.

Why BYI Matters: Real-World Use Cases

BYI isn’t just a concept; it’s a game-changer for industries that rely on collaboration. Here are a few examples where BYI shines:

FinTech: BYI allows banks and merchants to integrate payment solutions, virtual cards, or customer management tools seamlessly. Imagine a retailer using a plug-and-play payment button to start accepting transactions instantly.
EduTech: Schools can bring in tools like Zoom for virtual classes or integrate learning management systems (LMS) for automated grading—all within a single platform.
HealthTech: BYI enables health platforms to connect with wearable devices, syncing real-time health data for patient monitoring and diagnosis.

The Human Impact of BYI

What makes BYI truly powerful is the human element. It’s not just about technology—it’s about creating solutions that fit into people’s lives effortlessly. Here’s why it works:

Empowerment Through Choice: BYI lets businesses pick and choose integrations that fit their unique needs. No one-size-fits-all solutions here.
Scalability Made Simple: BYI ecosystems grow as businesses grow. Adding or removing integrations is easy, making it perfect for evolving needs.
Collaboration Over Competition: BYI encourages companies to work together, driving innovation and delivering better outcomes for end users.

What’s Next for BYI?

The future of BYI is bright and brimming with potential. Here are some trends to watch:

AI-Powered Integrations: Machine learning models will enable smarter, more adaptive integrations.
No-Code Solutions: BYI is becoming even more accessible with tools that allow non-developers to create workflows through simple drag-and-drop interfaces.
Blockchain Ecosystems: Decentralized apps (dApps) will bring transparency and security to integrations, particularly in FinTech and HealthTech.

Final Thoughts

Bring Your Integration (BYI) isn’t just about connecting tools—it’s about connecting people to solutions that make their lives better. It’s a framework that thrives on collaboration, innovation, and adaptability, empowering businesses to build ecosystems that stand the test of time.

Whether you’re a developer building integrations, a business leader exploring partnerships, or a user reaping the benefits of a connected world, BYI is here to make your journey seamless, scalable, and impactful.

So, what’s your integration story? Let’s build something amazing together. 🚀

Ensuring Secure User Sessions: A Guide to Logging Out Users Due to Inactivity in PHP

Shamsuddeen Omacy — Sun, 14 May 2023 19:52:32 +0000

Securely logging out users from your web app due to inactivity is an important security measure to prevent unauthorized access to sensitive data. Here are some steps you can take to securely log out users due to inactivity:

Step 1: Set session timeout

In your PHP code, set the session timeout using the session.gc_maxlifetime setting. This setting determines the maximum lifetime of a session in seconds.

// Set session timeout to 30 minutes (1800 seconds)
ini_set('session.gc_maxlifetime', 1800);

// Start session
session_start();

Step 2: Display warning message

Create a JavaScript function to display a warning message to users before logging them out due to inactivity. This function will be called after the session timeout has expired.

function showTimeoutWarning() {
  // Display warning message to user
  alert('Your session will expire soon. Please click OK to continue.');
}

Step 3: Confirm logout

Create a logout page to confirm that the user wants to log out. This page will be displayed after the session timeout has expired.

<?php
// Check if user clicked logout button
if (isset($_POST['logout'])) {
  // Invalidate session
  session_unset();
  session_destroy();

  // Clear cookies
  setcookie('PHPSESSID', '', time() - 3600, '/');

  // Redirect to login page
  header('Location: login.php');
  exit();
}
?>

<!DOCTYPE html>
<html>
<head>
  <title>Confirm Logout</title>
</head>
<body>
  <h1>Are you sure you want to log out?</h1>
  <form method="post">
    <input type="submit" name="logout" value="Log Out">
  </form>
</body>
</html>

Step 4: Invalidate session and clear cookies

In your PHP code, invalidate the user's session and clear any cookies associated with the session when logging them out due to inactivity.

// Check if session has timed out
if (isset($_SESSION['LAST_ACTIVITY']) && (time() - $_SESSION['LAST_ACTIVITY'] > ini_get('session.gc_maxlifetime'))) {
  // Invalidate session
  session_unset();
  session_destroy();

  // Clear cookies
  setcookie('PHPSESSID', '', time() - 3600, '/');

  // Redirect to logout page
  header('Location: logout.php');
  exit();
}

// Update last activity time
$_SESSION['LAST_ACTIVITY'] = time();

Step 5: Redirect to login page

In your PHP code, redirect the user to the login page after logging them out due to inactivity.

// Redirect to login page if user is not authenticated
if (!isset($_SESSION['user_id'])) {
  header('Location: login.php');
  exit();
}

By following these steps, you can securely log out users from your web app due to inactivity, and help prevent unauthorized access to sensitive data.

Locking Down Your RESTful API: Essential Practices for Bulletproof Security

Shamsuddeen Omacy — Sun, 07 May 2023 21:12:20 +0000

In today's interconnected world, securing your RESTful API is of paramount importance. With APIs serving as the backbone of modern applications, their vulnerabilities can expose sensitive data and compromise user privacy. In this blog post, we will explore essential best practices that will help you fortify your RESTful API and safeguard it from potential threats.

1. Authentication and Authorization:

Implementing robust authentication and authorization mechanisms is the first step towards securing your API. Require clients to authenticate using secure protocols such as OAuth 2.0 or JSON Web Tokens (JWT). Additionally, adopt strong password policies, enforce multi-factor authentication where possible, and regularly rotate access tokens to minimize the risk of unauthorized access.

2. Transport Layer Security (TLS):

Encrypting data in transit is crucial for preventing eavesdropping and data tampering. Utilize TLS, specifically the latest version, to establish secure communication channels between clients and your API. Ensure that all endpoints are accessible only through HTTPS, thereby protecting sensitive information from interception and unauthorized manipulation.

3. Input Validation and Sanitization:

One of the most common attack vectors is injection attacks, such as SQL and NoSQL injections. Implement strict input validation and sanitization practices to prevent malicious code injection. Use parameterized queries or prepared statements when interacting with databases, and sanitize user-supplied inputs to mitigate the risk of code execution or data breaches.

4. Rate Limiting and Throttling:

Protect your API from abuse and denial-of-service attacks by implementing rate limiting and throttling mechanisms. Set reasonable limits on the number of requests a client can make within a given timeframe. This helps prevent brute-force attacks, resource exhaustion, and ensures fair usage of your API's resources.

5. Role-Based Access Control (RBAC):

Implement RBAC to enforce fine-grained access control and limit privileges based on user roles. Assign appropriate permissions to users or client applications, allowing them access only to the resources and actions they require. Regularly review and update role assignments to maintain the principle of least privilege.

6. Error Handling and Logging:

Proper error handling and logging are critical for identifying and addressing potential security issues. Avoid exposing sensitive information in error messages, as this could aid attackers in exploiting vulnerabilities. Instead, provide informative yet generic error messages to users while logging detailed errors on the server-side for analysis and troubleshooting purposes.

7. API Versioning:

Implementing API versioning allows for gradual updates and ensures backward compatibility. By versioning your API, you can avoid breaking changes that might impact the security of existing integrations. It also enables you to roll out security patches or new security measures without disrupting the functionality of older API versions.

8. Regular Security Audits and Penetration Testing:

Perform regular security audits and penetration testing to identify vulnerabilities and weaknesses in your API. Engage third-party security experts to conduct thorough assessments and simulate attacks to evaluate your API's resilience. Address the identified issues promptly to stay ahead of potential threats and ensure continuous improvement of your API's security posture.

Conclusion:

Securing your RESTful API requires a comprehensive approach that encompasses authentication, encryption, input validation, access control, error handling, and regular audits. By following these best practices, you can significantly enhance the security of your API and protect sensitive data from unauthorized access and malicious attacks. Remember, security is an ongoing process, and staying vigilant and proactive is key to maintaining the integrity and trustworthiness of your API.

Build a Basic Note-Taking App with MongoDB, Node.js, Express, and Bootstrap: A Step-by-Step Guide for Beginners

Shamsuddeen Omacy — Wed, 26 Apr 2023 23:52:24 +0000

In today's digital age, note-taking has become an essential part of our daily routine. From jotting down quick reminders to organizing important ideas and thoughts, note-taking has proven to be an effective way of enhancing productivity and keeping track of our goals. In this tutorial, we'll guide you through the process of building a basic note-taking app using MongoDB, Node.js, Express, and Bootstrap. With our step-by-step approach, even beginners can follow along and create a fully functional note-taking app that's both user-friendly and visually appealing. Whether you're a student looking to organize your studies or a professional seeking to streamline your work processes, this tutorial is for you. Let's get started!

Step 1: Setup your development environment

Before you start, you need to set up your development environment. Here's what you need:

MongoDB: Install MongoDB on your machine and start the MongoDB server.
Node.js: Install Node.js on your machine.
Text editor: Use any text editor or IDE of your choice to write your code.

Step 2: Create a new Node.js project

Open your terminal and create a new folder for your project. Then, navigate to that folder and run the following command to create a new Node.js project:

npm init

This command will prompt you to enter some details about your project, such as the name, version, description, author, and license. You can either enter the details or press enter to accept the defaults.

Step 3: Install required packages

To create a note-taking app, we need to install the following packages:

express: A popular Node.js framework for building web applications.
mongoose: A MongoDB object modeling tool designed to work in an asynchronous environment.
ejs: A simple templating language that lets you generate HTML markup with plain JavaScript.
body-parser: A middleware that allows you to parse incoming request bodies in a middleware before your handlers.
Run the following command in your terminal to install these packages:

npm install express mongoose ejs body-parser --save

Step 4: Create the app structure

Create the following files and folders in your project folder:

app.js: This is the main file of your app where you'll configure the express app.
views/: This folder will contain all the ejs templates for your app.
public/: This folder will contain all the static files for your app, such as CSS, images, and JavaScript.
routes/: This folder will contain all the routes for your app.
models/: This folder will contain all the models for your app.

Step 5: Configure the app

Open the app.js file and add the following code:

const express = require('express');
const bodyParser = require('body-parser');
const mongoose = require('mongoose');
const app = express();

// Connect to MongoDB
mongoose.connect('mongodb://localhost/notes', { useNewUrlParser: true, useUnifiedTopology: true })
    .then(() => console.log('Connected to MongoDB'))
    .catch(err => console.log('Could not connect to MongoDB'));

// Set up body-parser middleware
app.use(bodyParser.urlencoded({ extended: false }));

// Set up ejs as the view engine
app.set('view engine', 'ejs');

// Set up the static files middleware
app.use(express.static('public'));

// Import routes
const notesRoutes = require('./routes/notes');

// Set up the routes middleware
app.use('/notes', notesRoutes);
// Home page route
app.get('/', (req, res) => {
    res.redirect('/notes');
});

// Start the server
app.listen(3000, () => console.log('Server started on port 3000'));

Here, we're importing the required packages, connecting to the MongoDB server, setting up the middleware, and starting the server.

Step 6: Create the Note model

Create a new file called Note.js in the models/ folder and add the following code:

const mongoose = require('mongoose');

const NoteSchema = new mongoose.Schema({
    title: String,
    content: String
});

const Note = mongoose.model('Note', NoteSchema);

module.exports = Note;

This code defines the Note schema and exports the Note model.

Step 7: Create the routes

Create a new file called notes.js in the routes/ folder and add the following code:

const express = require('express');
const router = express.Router();
const Note = require('../models/Note');

// Get all notes
router.get('/', async (req, res) => {
    const notes = await Note.find();
    res.render('index', { notes });
});

// Create a new note
router.post('/', async (req, res) => {
    const { title, content } = req.body;
    const note = new Note({ title, content });
    await note.save();
    res.redirect('/notes');
});

module.exports = router;

Here, we're defining two routes - one for getting all notes and another for creating a new note. In the get route, we're fetching all notes from the database and rendering them using the index.ejs template. In the post route, we're creating a new note and redirecting the user back to the index page.

Step 8: Create the views

Create a new file called index.ejs in the views/ folder and add the following code:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Note Taking App</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha3/dist/css/bootstrap.min.css" rel="stylesheet" >
</head>
<body class="container">
    <h1>Note Taking App</h1>

    <form action="/notes" method="post">
        <div class="form-group">
            <label for="title">Title</label>
            <input type="text" name="title" id="title" class="form-control" placeholder="Title" required>
        </div>

        <div class="form-group">
            <label for="content">Content</label>
            <textarea name="content" id="content" class="form-control" placeholder="Content" required></textarea>
        </div>

        <div class="form-group">
            <button type="submit" class="btn btn-primary" >Save Note</button>
        </div>
    </form>

    <hr>

    <% if (notes.length > 0) { %>
        <% notes.forEach(note => { %>
            <h2><%= note.title %></h2>
            <p><%= note.content %></p>
        <% }) %>
    <% } else { %>
        <p>No notes found.</p>
    <% } %>
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha3/dist/js/bootstrap.bundle.min.js"></script>
</body>
</html>

Here, we're creating a form for adding a new note and displaying all existing notes using a loop.

Step 9: Run the app

Now that we've set up everything, we can start the app by running the following command in your terminal:

node app.js

This will start the server on port 3000. Open your web browser and go to http://localhost:3000/ to view the app.

Congratulations! You've successfully created a basic note-taking app using MongoDB, NodeJS, Express JS, and Bootstrap.

GitHub Repo: https://github.com/Shamsuddeen/note-taker

Read my previous tutorial on How to Build a Simple Blog with MongoDB, Express JS, and Node in 5 Easy Steps

Understanding API Status Codes: A Developer's Guide

Shamsuddeen Omacy — Sat, 22 Apr 2023 22:55:03 +0000

As web applications become more complex and interconnected, the need for standardized communication between systems has become essential. This is where Application Programming Interfaces (APIs) come into play. APIs allow different software systems to communicate with each other, enabling seamless data exchange and functionality.

One crucial aspect of APIs is their use of status codes. API status codes are standard HTTP response codes that provide information about the outcome of an API request. In this article, we'll explore the different types of API status codes and what they mean for developers.

HTTP Status Codes

API status codes are based on HTTP status codes, which are three-digit numbers that are returned by a server in response to a client request. HTTP status codes are divided into five classes, each with its own range of codes:

1xx: Informational
2xx: Success
3xx: Redirection
4xx: Client Errors
5xx: Server Errors

Each of these classes corresponds to a specific type of outcome. For example, a 2xx code indicates that a request was successful, while a 4xx code indicates that the client made an error.

API Status Codes

API status codes are a subset of HTTP status codes that are specifically used in API communication. While there are many HTTP status codes, only a subset of these are commonly used in API communication. The most commonly used API status codes are:

200 OK: The request was successful, and the response contains the requested data.
201 Created: The request was successful, and a new resource has been created.
204 No Content: The request was successful, but there is no data to return.
400 Bad Request: The request was malformed or invalid.
401 Unauthorized: The request requires authentication, but the user has not provided valid credentials.
403 Forbidden: The user does not have permission to access the requested resource.
404 Not Found: The requested resource could not be found.
500 Internal Server Error: The server encountered an error while processing the request.

Let's take a closer look at some of these codes.

200 OK

The 200 OK code is the most common API status code. It indicates that the request was successful, and the response contains the requested data. For example, if a client requests information about a user, and the server successfully returns that information, it will return a 200 OK code.

400 Bad Request

The 400 Bad Request code is returned when the client sends a request that is malformed or invalid. This could be because of missing or incorrect parameters, or other issues with the request. For example, if a client sends a request to create a new user but does not include a required field like an email address, the server will return a 400 Bad Request code.

401 Unauthorized

The 401 Unauthorized code is returned when the client attempts to access a protected resource without providing valid authentication credentials. For example, if a client attempts to access a user's account information without providing a valid username and password, the server will return a 401 Unauthorized code.

403 Forbidden

The 403 Forbidden code is returned when the client does not have permission to access the requested resource. This could be because the client is not authorized to access the resource, or because the resource does not exist. For example, if a client attempts to access a resource that is only available to administrators, the server will return a 403 Forbidden code.

Conclusion

API status codes are a critical aspect of API communication. They provide developers with essential information about the outcome of API requests, enabling them to build more robust and reliable software systems. By understanding the different types of API status codes and what they mean, developers can build better error handling and response mechanisms into their applications, improving the user experience and overall functionality of the system.

In addition to the commonly used API status codes, some APIs may use custom status codes to provide more specific information about the outcome of a request. For example, an API might use a 422 Unprocessable Entity code to indicate that a request was well-formed but was unable to be processed because of semantic errors. It's important for developers to be aware of any custom status codes used by the APIs they are working with.

Finally, it's worth noting that while API status codes can be helpful for developers, they are not always sufficient on their own. In some cases, it may be necessary to include additional information in the response body to provide context and help the client application understand the outcome of the request. For example, if a request fails because of a rate limit, the server might include information about when the limit will reset and how many requests are remaining.

In summary, API status codes are an essential part of API communication. They provide developers with information about the outcome of API requests and help them build more reliable and robust software systems. By understanding the different types of API status codes and how they are used, developers can build better applications and improve the overall user experience.

Building a Simple Blog with MongoDB, Express JS, and Node in 5 Easy Steps

Shamsuddeen Omacy — Sun, 16 Apr 2023 16:02:23 +0000

Step 1: Setting up the Environment

The first step is to set up the development environment. You will need to install Node.js, MongoDB, and Express.js. You can download Node.js from the official website and MongoDB from the MongoDB website. Express.js can be installed using the npm package manager. Once you have installed all the necessary components, you can create a new project folder and start working on your blog.

Step 2: Creating the Database

The second step is to create the database. You will need to start the MongoDB server and create a new database for your blog. You can do this by opening a new terminal window and typing the following command:

mongosh
use blog

This will create a new database called "blog" and switch to it. You can now create a new collection for your blog posts using the following command:

db.createCollection('posts')

Step 3: Setting up the Backend

The third step is to set up the backend of your blog. You can do this by creating a new file called "server.js" in your project folder. In this file, you will need to import the necessary modules and create a new Express.js app. You can use the following code as a starting point:

const express = require('express');
const bodyParser = require('body-parser');
const MongoClient = require('mongodb').MongoClient;

const app = express();
const port = 3000;

app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());

MongoClient.connect('mongodb://localhost:27017/blog', (err, client) => {
  if (err) throw err;
  console.log('Connected to MongoDB');
  const db = client.db('blog');

  // Add routes here

  app.listen(port, () => {
    console.log(`Server listening on port ${port}`);
  });
});

This code sets up an Express.js app and connects to the MongoDB database. You will need to add routes to the app to handle requests from the frontend.

Step 4: Adding Routes

The fourth step is to add routes to your app. You can create a new file called "routes.js" in your project folder and add the following code:

const express = require('express');
const router = express.Router();
const MongoClient = require('mongodb').MongoClient;

router.get('/posts', (req, res) => {
  const db = req.app.locals.db;
  db.collection('posts').find().toArray((err, result) => {
    if (err) throw err;
    res.send(result);
  });
});

router.post('/posts', (req, res) => {
  const db = req.app.locals.db;
  const post = {
    title: req.body.title,
    content: req.body.content,
  };
  db.collection('posts').insertOne(post, (err, result) => {
    if (err) throw err;
    res.send(result.ops[0]);
  });
});

module.exports = router;

This code sets up two routes: one for getting all blog posts and one for creating a new blog post. These routes use the MongoDB driver to interact with the database.

Step 5: Setting up the Frontend

The final step is to set up the frontend of your blog. You can create a new HTML file called "index.html" in your project folder and add the following code:

<!DOCTYPE html>
<html>
  <head>
    <title>My Blog</title>
  </head>
  <body>
    <h1>My Blog</h1>

    <form id="postForm">
      <label for="title">Title:</label>
      <input type="text" id="title" name="title">

      <label for="content">Content:</label>
      <textarea id="content" name="content"></textarea>

      <button type="submit">Create Post</button>
    </form>

    <ul id="postsList"></ul>

    <script>
      const form = document.getElementById('postForm');
      form.addEventListener('submit', event => {
        event.preventDefault();

        const title = document.getElementById('title').value;
        const content = document.getElementById('content').value;

        fetch('/posts', {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json'
          },
          body: JSON.stringify({ title, content })
        })
        .then(response => response.json())
        .then(post => {
          const postsList = document.getElementById('postsList');
          const li = document.createElement('li');
          li.textContent = `${post.title}: ${post.content}`;
          postsList.appendChild(li);
        });
      });

      fetch('/posts')
        .then(response => response.json())
        .then(posts => {
          const postsList = document.getElementById('postsList');
          posts.forEach(post => {
            const li = document.createElement('li');
            li.textContent = `${post.title}: ${post.content}`;
            postsList.appendChild(li);
          });
        });
    </script>
  </body>
</html>

This code sets up an HTML form to create new blog posts and displays all the posts on the page. The form uses the fetch API to make a POST request to the backend API and the GET request to get all the posts and displays them on the page.

That's it! With these five simple steps, you can create a basic blog using MongoDB, Express.js, and Node.js. Of course, this is just a starting point, and you can customize and extend this blog as per your requirements.

Building a Basic CRUD API with Node.js, MongoDB, and Express.js: A Beginner's Tutorial

Shamsuddeen Omacy — Thu, 06 Apr 2023 09:18:22 +0000

In this tutorial, we will be building a basic CRUD (Create, Read, Update, Delete) API using Node.js, MongoDB, and Express.js. A CRUD API is a fundamental part of most web applications, as it allows users to interact with and manipulate data stored in a database.

We will start by setting up a new Node.js project and installing the required dependencies, including Express.js and Mongoose, an Object-Document Mapper (ODM) for MongoDB. We will then connect to our MongoDB database and define a data model for our users collection.

Next, we will create API endpoints using Express.js for all four CRUD operations, including creating a new user, retrieving all users, retrieving a single user, updating a user, and deleting a user.

This tutorial is aimed at beginners who are new to Node.js, MongoDB, and Express.js. By the end of this tutorial, you should have a good understanding of how to build a basic CRUD API and how to interact with a MongoDB database using Mongoose. Let's get started!

Before we start, let me explain what CRUD means:

C: Create - Add a new item to the database
R: Read - Retrieve an item from the database
U: Update - Modify an existing item in the database
D: Delete - Remove an item from the database

To create a basic CRUD API, we will follow the steps below:

Step 1: Install Required Dependencies

First, we need to create a new folder and setup Node.js project and install the required dependencies.
Run the following command in your terminal:

mkdir nem-crud && cd nem-crud

Then run:
npm init -y

This command will create a new Node.js project with a package.json file.

Next, we will install the following dependencies:

express: A popular Node.js web framework
mongoose: An Object-Document Mapper (ODM) for MongoDB
To install these dependencies, run the following command:

npm install express mongoose

Step 2: Connect to MongoDB

Next, we need to connect to our MongoDB database using Mongoose. To do this, create a new file called db.js in your project's root directory and add the following code:

const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost/my_database', {
  useNewUrlParser: true,
  useUnifiedTopology: true
})
.then(() => console.log('MongoDB connected...'))
.catch(err => console.log(err));

In the above code, we first import the mongoose module and then connect to our MongoDB database using the mongoose.connect() method. We also pass some options to the mongoose.connect() method, which are necessary for avoiding deprecation warnings. Finally, we log a message to the console to confirm that we have connected to the database.

Note: Make sure to replace my_database with the name of your own MongoDB database.

Step 3: Define a Model

Next, we need to define a model for our data. In this example, we will create a model for users. To do this, create a new file called user.js in your project's root directory and add the following code:

const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
  name: String,
  email: String,
  password: String
});

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

module.exports = User;

In the above code, we first import the mongoose module and then define a schema for our users collection. The schema defines the structure of the data in our collection. In this example, we have defined three fields: name, email, and password.

After defining the schema, we create a User model using the mongoose.model() method and export it so that we can use it in our API.

Step 4: Create API Endpoints

Next, we need to create our API endpoints using Express.js. In this example, we will create endpoints for all four CRUD operations. To do this, create a new file called app.js in your project's root directory and add the following code:

const express = require('express');
const User = require('./user');

const app = express();
app.use(express.json());

// Get all users
app.get('/users', async (req, res) => {
  try {
    const users = await User.find();
    res.json(users);
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

// Get a single user
app.get('/users/:id', getUser, (req, res) => {
  res.json(res.user);
});

// Create a new user
app.post('/users', async (req, res) => {
  const user = new User({
    name: req.body.name,
    email: req.body.email,
    password: req.body.password
  });

  try {
    const newUser = await user.save();
    res.status(201).json(newUser);
  } catch (err) {
    res.status(400).json({ message: err.message });
  }
});

// Update a user
app.patch('/users/:id', getUser, async (req, res) => {
  if (req.body.name != null) {
    res.user.name = req.body.name;
  }

  if (req.body.email != null) {
    res.user.email = req.body.email;
  }

  if (req.body.password != null) {
    res.user.password = req.body.password;
  }

  try {
    const updatedUser = await res.user.save();
    res.json(updatedUser);
  } catch (err) {
    res.status(400).json({ message: err.message });
  }
});

// Delete a user
app.delete('/users/:id', getUser, async (req, res) => {
  try {
    await res.user.remove();
    res.json({ message: 'User deleted' });
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

// Middleware function to get a single user by ID
async function getUser(req, res, next) {
  let user;
  try {
    user = await User.findById(req.params.id);
    if (user == null) {
      return res.status(404).json({ message: 'Cannot find user' });
    }
  } catch (err) {
    return res.status(500).json({ message: err.message });
  }

  res.user = user;
  next();
}

app.listen(3000, () => console.log('Server started...'));

In the above code, we first import the express module and our User model. We then create a new instance of express and use express.json() middleware to parse incoming JSON data.

Next, we define our API endpoints using the following HTTP methods:

GET: Used to retrieve data
POST: Used to create data
PATCH: Used to update data
DELETE: Used to delete data

For each endpoint, we define a URL path and a callback function that handles the incoming requests and sends back the appropriate responses.

We also define a middleware function called getUser that retrieves a single user by ID and sets it as a property of the response object. This function is used by the GET, PATCH, and DELETE endpoints to retrieve and manipulate a single user.

Step 5: Start the Server

To start the server run npm start in your terminal.

Finally, we start the server listening on port 3000 and log a message to the console to confirm that the server has started.

Revolutionizing Banking: How Cobranded Cards and BaaS Are Changing the Game

Shamsuddeen Omacy — Mon, 27 Mar 2023 13:55:12 +0000

Banking as a Service (BaaS) is a relatively new concept in the banking industry that allows non-bank companies to offer banking services to their customers using the infrastructure of a partnering bank. One of the strategies to increase the banking portfolio and boost partner retail transaction turnover is the issuance of cobranded cards that offer a hybrid of bank loyalty and merchant loyalty programs.

The issuance of cobranded cards was one of the strategies used to increase the bank’s portfolio and partner transaction volume. It was not always an easy task, especially when it came to creating two balances. However, I recently read about a product launched by a FinTech company Sudo that allows retailers working with the company to have their own branded cards. These cards can be used for online and offline payments, with the ability to set limits and monitor expenses.

Thanks to embedded finance technology, customers can create virtual and physical cards in just a few clicks. Sellers can offer customization options, such as a unique design to connect with their brand or environmentally friendly materials like biodegradable plastic. For retailers, the Sudo card is marketed as a way to save on acquiring fees and earn more by receiving a percentage of card payments. By partnering with fintech companies like

Sudo, retailers can expand their financial services offerings, provide a better customer experience, and increase customer loyalty. Meanwhile, partnering banks benefit from new revenue streams and the opportunity to tap into the fintech market.

Overall, BaaS and cobranded cards have the potential to transform the banking industry and provide new opportunities for both banks and non-bank companies.