Het ontwikkelen van een multi-tenant full-stack applicatie met React (frontend) en Node.js (backend) vereist een doordacht ontwerp van het databaseschema, een robuuste aanpak voor huurdersidentificatie en sterke beveiligingsmaatregelen om gegevensisolatie te waarborgen. Hieronder volgt een gedetailleerde gids: 1. Databaseschema Ontwerp a. Keuze van Database: - Overweeg relationele databases zoals PostgreSQL of MySQL voor gestructureerde gegevens. - Gebruik indien nodig schemas of schematische scheiding voor extra isolatie. b. Basisstructuur: - Maak een tabel ‘Tenants’ (huurders): - tenant_id (primaire sleutel) - naam - contactgegevens - andere tenant-specifieke info - Voeg voor elke relevante entiteit (bijvoorbeeld Gebruikers, Projecten, Bestanden) een ‘tenant_id’ kolom toe: - Gebruikers: - user_id - tenant_id (foreign key) - naam - email - wachtwoord_hash - rol/rechten - Andere tabellen (bijv. Projecten, Bestanden) volgen hetzelfde patroon. c. Optioneel: Schemas - Voor betere isolatie kan je per tenant een aparte schema maken (bijvoorbeeld in PostgreSQL). - Dit maakt querying complexer, maar verhoogt de isolatie. 2. Huurdersidentificatie en Authenticatie a. Authenticatie: - Implementeer een veilige login met JWT (JSON Web Tokens) of sessies. - Bij login: - Verifieer gebruikersgegevens. - Voeg een ‘tenant_id’ toe aan het token payload. - Bewaar de ‘tenant_id’ niet alleen in het token, maar ook in de database om consistentie te waarborgen. b. Autorisatie: - Bij elke API-aanroep: - Verifieer het token. - Extract ‘tenant_id’ uit het token. - Gebruik ‘tenant_id’ in database queries om data te filteren. 3. Gegevensbeveiliging en Isolatie tussen Huurders a. Query Filtering: - Zorg dat alle database queries automatisch filteren op ‘tenant_id’. - Gebruik ORM’s zoals Sequelize, TypeORM of Prisma om dit te structureren. - Bijvoorbeeld: ```js const user = await User.findOne({ where: { email: 'test@example.com', tenant_id: currentTenantId } }); ``` b. Middleware en Validatie: - Implementeer middleware die het ‘tenant_id’ uit het token haalt en toevoegt aan de request context. - Controleer dat elke actie door een gebruiker binnen dezelfde tenant gebeurt. c. Role-Based Access Control (RBAC): - Definieer rollen en rechten binnen elke tenant. - Beperk toegang tot gegevens op basis van rol. d. Data Encryptie: - Versleutel gevoelige gegevens zowel in rust (bijvoorbeeld met database encryptie) als tijdens transmissie (HTTPS). - Overweeg veldniveau encryptie voor uiterst gevoelige informatie. e. Scheiding op database niveau: - Als extra isolatie, gebruik aparte databases of schema’s per tenant (voor grote applicaties). 4. Extra Best Practices - Logging: Log toegang en datawijzigingen per tenant. - Monitoring: Houd prestaties en beveiligingsincidenten bij. - Back-up & Herstel: Maak gescheiden back-ups per tenant indien nodig. 5. Samenvatting - Ontwerp een gestructureerd databaseschema met ‘tenant_id’ kolommen. - Gebruik JWT of sessies waarbij ‘tenant_id’ wordt opgeslagen en gevalideerd. - Filter alle queries op ‘tenant_id’ om dataisolatie te garanderen. - Implementeer role-based toegang en versleutel gegevens waar mogelijk. - Overweeg schematische isolatie voor extra beveiliging bij grote schaal. Door deze aanpak te volgen, zorg je voor een veilige, geïsoleerde multi-tenant omgeving waarin meerdere huurders onafhankelijk en veilig gebruik kunnen maken van dezelfde applicatie.

Hier is een gedetailleerde gids voor het bouwen van een multi-tenant applicatie met React en Node.js: ## 1. Database Schema Ontwerp ### Optie 1: Shared Database, Shared Schema (Aanbevolen voor starters) ```sql -- Huurders tabel CREATE TABLE tenants ( id UUID PRIMARY KEY DEFAULT gen_random_uuid(), name VARCHAR(255) NOT NULL, subdomain VARCHAR(100) UNIQUE NOT NULL, created_at TIMESTAMP DEFAULT NOW(), status VARCHAR(50) DEFAULT 'active' ); -- Gebruikers tabel met tenant relatie CREATE TABLE users ( id UUID PRIMARY KEY DEFAULT gen_random_uuid(), tenant_id UUID NOT NULL REFERENCES tenants(id), email VARCHAR(255) NOT NULL, password_hash VARCHAR(255) NOT NULL, role VARCHAR(50) NOT NULL, created_at TIMESTAMP DEFAULT NOW(), UNIQUE(tenant_id, email) ); -- Voorbeeld data tabel met tenant isolatie CREATE TABLE products ( id UUID PRIMARY KEY DEFAULT gen_random_uuid(), tenant_id UUID NOT NULL REFERENCES tenants(id), name VARCHAR(255) NOT NULL, price DECIMAL(10,2) NOT NULL, created_at TIMESTAMP DEFAULT NOW() ); -- Indexen voor prestaties CREATE INDEX idx_products_tenant_id ON products(tenant_id); CREATE INDEX idx_users_tenant_id ON users(tenant_id); ``` ### Optie 2: Shared Database, Separate Schemas ```sql -- Schema per tenant aanmaken CREATE SCHEMA tenant_1; CREATE SCHEMA tenant_2; -- Zelfde tabel structuur in elk schema CREATE TABLE tenant_1.products (...); CREATE TABLE tenant_2.products (...); ``` ## 2. Tenant Identificatie Strategie ### Backend Middleware (Node.js/Express) ```javascript // middleware/tenantMiddleware.js const Tenant = require('../models/Tenant'); const identifyTenant = async (req, res, next) => { try { // Methode 1: Via subdomain const host = req.get('host'); const subdomain = host.split('.')[0]; // Methode 2: Via JWT token const token = req.headers.authorization?.split(' ')[1]; if (token) { const decoded = jwt.verify(token, process.env.JWT_SECRET); req.tenantId = decoded.tenantId; } // Methode 3: Via custom header const tenantHeader = req.headers['x-tenant-id']; // Tenant valideren const tenant = await Tenant.findOne({ $or: [ { subdomain: subdomain }, { _id: tenantHeader || req.tenantId } ] }); if (!tenant) { return res.status(404).json({ error: 'Tenant niet gevonden' }); } req.tenant = tenant; next(); } catch (error) { res.status(401).json({ error: 'Tenant identificatie mislukt' }); } }; module.exports = identifyTenant; ``` ### Context Provider voor Tenant Management ```javascript // context/TenantContext.js import React, { createContext, useContext, useState, useEffect } from 'react'; const TenantContext = createContext(); export const TenantProvider = ({ children }) => { const [currentTenant, setCurrentTenant] = useState(null); const [tenants, setTenants] = useState([]); const detectTenant = () => { // Detectie via subdomain const hostname = window.location.hostname; const subdomain = hostname.split('.')[0]; // Of via URL parameter const urlParams = new URLSearchParams(window.location.search); const tenantParam = urlParams.get('tenant'); return tenantParam || subdomain; }; const switchTenant = (tenantId) => { // Update alle requests met nieuwe tenant context localStorage.setItem('currentTenant', tenantId); setCurrentTenant(tenantId); }; useEffect(() => { const tenantIdentifier = detectTenant(); setCurrentTenant(tenantIdentifier); }, []); return ( <TenantContext.Provider value={{ currentTenant, tenants, switchTenant, detectTenant }}> {children} </TenantContext.Provider> ); }; export const useTenant = () => useContext(TenantContext); ``` ## 3. Beveiligde Database Queries ### Repository Pattern met Tenant Isolatie ```javascript // repositories/ProductRepository.js class ProductRepository { constructor(tenantId) { this.tenantId = tenantId; } async findAll() { return await Product.find({ tenantId: this.tenantId }); } async findById(id) { return await Product.findOne({ _id: id, tenantId: this.tenantId }); } async create(productData) { return await Product.create({ ...productData, tenantId: this.tenantId }); } async update(id, productData) { return await Product.findOneAndUpdate( { _id: id, tenantId: this.tenantId }, productData, { new: true } ); } async delete(id) { return await Product.findOneAndDelete({ _id: id, tenantId: this.tenantId }); } } // Gebruik in controllers const productController = { getProducts: async (req, res) => { try { const productRepo = new ProductRepository(req.tenant._id); const products = await productRepo.findAll(); res.json(products); } catch (error) { res.status(500).json({ error: error.message }); } } }; ``` ## 4. Authenticatie & Autorizatie ### JWT Token met Tenant Info ```javascript // auth/jwtUtils.js const jwt = require('jsonwebtoken'); const generateToken = (user) => { return jwt.sign( { userId: user._id, tenantId: user.tenantId, email: user.email, role: user.role }, process.env.JWT_SECRET, { expiresIn: '24h' } ); }; const verifyToken = (token) => { return jwt.verify(token, process.env.JWT_SECRET); }; // Autorizatie middleware const requireRole = (allowedRoles) => { return (req, res, next) => { if (!req.user) { return res.status(401).json({ error: 'Niet geauthenticeerd' }); } if (!allowedRoles.includes(req.user.role)) { return res.status(403).json({ error: 'Onvoldoende rechten' }); } // Tenant isolatie check if (req.user.tenantId !== req.tenant._id.toString()) { return res.status(403).json({ error: 'Toegang geweigerd voor deze tenant' }); } next(); }; }; ``` ## 5. Frontend Implementatie ### Axios Interceptor voor Tenant Headers ```javascript // utils/api.js import axios from 'axios'; import { useTenant } from '../context/TenantContext'; const api = axios.create({ baseURL: process.env.REACT_APP_API_URL, }); api.interceptors.request.use((config) => { const tenantId = localStorage.getItem('currentTenant'); if (tenantId) { config.headers['X-Tenant-ID'] = tenantId; } const token = localStorage.getItem('authToken'); if (token) { config.headers.Authorization = `Bearer ${token}`; } return config; }); api.interceptors.response.use( (response) => response, (error) => { if (error.response?.status === 403) { // Tenant toegang geweigerd window.location.href = '/tenant-error'; } return Promise.reject(error); } ); export default api; ``` ### Beveiligde React Component ```jsx // components/TenantAwareComponent.js import React, { useState, useEffect } from 'react'; import { useTenant } from '../context/TenantContext'; import api from '../utils/api'; const TenantAwareComponent = () => { const { currentTenant } = useTenant(); const [data, setData] = useState([]); const [loading, setLoading] = useState(true); useEffect(() => { const fetchData = async () => { try { setLoading(true); const response = await api.get('/api/products'); setData(response.data); } catch (error) { console.error('Fout bij ophalen data:', error); } finally { setLoading(false); } }; if (currentTenant) { fetchData(); } }, [currentTenant]); if (loading) return <div>Laden...</div>; return ( <div> <h2>Data voor {currentTenant}</h2> {/* Render je data hier */} </div> ); }; ``` ## 6. Beveiligingsmaatregelen ### Aanvullende Beveiliging ```javascript // security/querySanitizer.js const sanitizeQuery = (query, tenantId) => { // Zorg ervoor dat tenantId altijd wordt meegenomen if (typeof query === 'object') { return { ...query, tenantId }; } return { tenantId }; }; // Rate limiting per tenant const rateLimit = require('express-rate-limit'); const tenantLimiter = rateLimit({ windowMs: 15 * 60 * 1000, // 15 minuten max: (req) => { // Verschillende limits per tenant const tenantTier = req.tenant?.tier || 'basic'; return tenantTier === 'premium' ? 1000 : 100; }, message: 'Te veel requests van deze tenant' }); ``` ## 7. Best Practices 1. **Always include tenantId** in elke database query 2. **Use database constraints** voor referentiële integriteit 3. **Implement proper error handling** voor tenant-specific errors 4. **Regular security audits** voor tenant data isolatie 5. **Backup strategies** per tenant of globaal 6. **Monitoring en logging** per tenant Deze architectuur zorgt voor volledige data-isolatie tussen tenants terwijl je de voordelen behoudt van een gedeelde codebase en infrastructuur.