White Label Application
White Labelling is a common practice in software development. It allows a single application to be used by multiple clients. Each client can have their own branding, logo, color scheme, etc. This allows the client to feel like they have their own application. The application can be customized for each client without having to create a separate application for each client. This is a common practice in the SaaS (Software as a Service) industry.
Let's create a white labelling application using Node.js, Express, and MongoDB.
We will create a simple application that allows us to create clients and users. Each client will have their own users. The User can be a Merchant or even a separate application. For simplicity, we will just call them users and keep them in the same database.
Step 1 - Create a new project
mkdir white-label-app
cd white-label-app
npm init -y
npm install express mongoose
Client Model
models/client.js
const mongoose = require('mongoose');
const clientSchema = new mongoose.Schema({
name: {
type: String,
required: true,
unique: true
},
logo: {
type: String,
required: true
},
primaryColor: {
type: String,
required: true
},
secondaryColor: {
type: String,
required: true
},
font: {
type: String,
required: true
},
users: [{
type: mongoose.Schema.Types.ObjectId,
ref: 'User'
}]
});
const Client = mongoose.model('Client', clientSchema);
module.exports = Client;
User Model
models/user.js
const mongoose = require('mongoose');
const bcrypt = require('bcrypt');
const userSchema = new mongoose.Schema({
username: {
type: String,
required: true,
unique: true
},
password: {
type: String,
required: true,
minlength: 6
},
client: {
type: mongoose.Schema.Types.ObjectId,
ref: 'Client',
required: true
}
});
userSchema.pre('save', async function(next) {
const user = this;
if (user.isModified('password')) {
user.password = await bcrypt.hash(user.password, 8);
}
next();
});
const User = mongoose.model('User', userSchema);
module.exports = User;
Create the routes
routes/client.js
const express = require('express');
const router = express.Router();
const Client = require('../models/client');
router.post("/", async(req,res)=>{
try{
const client = new Client(req.body);
await client.save();
res.status(201).send(client);
}catch(e){
return res.status(400).json({error: e.message});
}
});
router.get("/", async(req,res)=>{
try{
const clients = await Client.find({});
res.send(clients);
}catch(e){
return res.status(400).json({error: e.message});
}
});
router.get("/:id", async(req,res)=>{
try{
const client = await Client.findById(req.params.id);
res.send(client);
}catch(e){
return res.status(400).json({error: e.message});
}
});
module.exports = router;
routes/user.js
const express = require("express");
const router = express.Router();
const User = require("../models/user");
const Client = require("../models/client");
router.post("/", async (req, res) => {
try {
const { username, password, client } = req.body;
if (!username || !password || !client) {
return res.status(400).json({ error: "Please provide all fields" });
}
const userExist = await User.findOne({ username });
if (userExist) {
return res.status(400).json({ error: "User already exists" });
}
const clientExists = await Client.findById(client);
console.log(clientExists);
if (!clientExists) {
return res.status(400).json({ error: "Client does not exist" });
}
const user = new User({ username, password, client: clientExists._id });
await user.save();
clientExists.users.push(user._id);
await clientExists.save();
res.status(201).send(user);
} catch (e) {
return res.status(400).json({ error: e.message });
}
});
router.get("/", async (req, res) => {
try {
const users = await User.find({});
res.send(users);
} catch (e) {
return res.status(400).json({ error: e.message });
}
});
module.exports = router;
index.js
const express = require('express');
const mongoose = require('mongoose');
const clientRouter = require('./routes/client');
const userRouter = require('./routes/user');
const app = express();
const port = process.env.PORT || 3000;
app.use(express.json());
app.use("/clients", clientRouter);
app.use("/users", userRouter);
mongoose.connect('mongodb://
localhost:27017/white-label-app');
app.listen(port, () => {
console.log(`Server is up on port ${port}`);
});
mongoose.connection.on('connected', () => {
console.log('Connected to MongoDB');
});
mongoose.connection.on('error', (error) => {
console.log(error);
});
node index.js
curl -X POST -H "Content-Type: application/json" -d '{"name":"Client 1","logo":"https://via.placeholder.com/150","primaryColor":"#000000","secondaryColor":"#ffffff","font":"Arial"}' http://localhost:3000/clients
curl -X POST -H "Content-Type: application/json" -d '{"username":"user1","password":"password","client":"5f9e9c9b9c9b9c9b9c9b9c9b"}' http://localhost:3000/users
curl -X GET http://localhost:3000/users
curl -X GET http://localhost:3000/users/5f9e9c9b9c9b9c9b9c9b9c9b
curl -X GET http://localhost:3000/clients
curl -X GET http://localhost:3000/clients/5f9e9c9b9c9b9c9b9c9b9c9b
Break it down
Let's break it down again.
- An application can have multiple clients.
- Each client can have multiple users.
- Each user can have their own username and password. Each client can have their own logo, color scheme, and font.
Conclusion
This is a very simple example of a white labelling application. You can take this further and create a more complex application. You can add more features to the application. Thank you for reading. I hope you learned something new today. Happy coding!
Questions
What approach do you take when creating a white labelling application? Do you have any tips or tricks? Let me know in the comments below.
Top comments (0)