MongoDB Packages

npm install @node-tenant/tenant-core
npm install @node-tenant/tenant-mongodb
npm install mongodb  # peer dependency

// Step 1: User visits "acme.myapp.com"
//       │
//       ▼
// Step 2: TenantMiddleware sees "acme", checks the Master List
//       │
//       ▼
// Step 3: TenantContextManager securely locks the request to "acme"
//       │
//       ├─► dbAdapter.switchTenant(activeTenant)
//       │        └─► Returns: client.db("tenant_acme")
//       │
//       └─► Step 4: Your route handler uses that specific database!

import { MongoClient } from 'mongodb';
import express from 'express';
import { TenantManager } from '@node-tenant/tenant-core';
import { tenantMiddleware, subdomainResolver } from '@node-tenant/tenant-express';
import { createMongoDBDatabaseAdapter } from '@node-tenant/tenant-mongodb';
import { createPrismaStorage } from '@node-tenant/tenant-storage-prisma';
import { PrismaClient } from '@prisma/client';

// 1. Connect to your MongoDB server
const mongoClient = new MongoClient(process.env.MONGODB_URI!);
await mongoClient.connect();

// 2. Setup the Data Plane (Where user data goes)
const dbAdapter = createMongoDBDatabaseAdapter({
  client: mongoClient,
  // If a customer's slug is "acme", their database will be named "tenant_acme"
  dbPrefix: 'tenant_',   
});

// 3. Setup the Control Plane (Where the master customer list is saved)
const prisma = new PrismaClient();
const storage = createPrismaStorage(prisma);

// 4. Combine them in the Manager
const manager = new TenantManager({ storage, databaseAdapter: dbAdapter });

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

// 5. Secure all routes
app.use(tenantMiddleware({ manager, resolver: subdomainResolver() }));

// 6. Access the secure database in your routes!
app.get('/api/orders', async (req, res) => {
  // It securely fetches the "tenant_acme" database for us
  const db = await dbAdapter.switchTenant((req as any).tenant);
  
  // Notice we don't need a "WHERE tenantId = ..." filter! 
  // It's impossible to see another customer's orders because we are in a totally different database.
  const orders = await db.collection('orders').find({}).toArray();
  res.json(orders);
});

app.listen(3000);

// When a new customer signs up — provision their MongoDB database
async function provisionTenant(slug: string, name: string) {
  // 1. Create tenant record in the control-plane
  const tenant = await manager.createTenant({ slug, name });

  // 2. Create their isolated MongoDB database
  await dbAdapter.createTenantDatabase(tenant);

  // 3. Run seed data
  await dbAdapter.seedTenant(tenant, async (db) => {
    await db.collection('settings').insertOne({
      tenantId: tenant.id,
      plan: 'free',
      createdAt: new Date(),
    });
    await db.collection('users').createIndex({ email: 1 }, { unique: true });
  });

  console.log('Tenant provisioned:', slug);
}

await provisionTenant('acme', 'Acme Corp');

// Permanently remove a tenant and ALL their data
async function offboardTenant(slug: string) {
  const tenant = await manager.getTenantBySlug(slug);

  // Drop the entire MongoDB database
  await dbAdapter.deleteTenantDatabase(tenant);

  // Remove from control-plane
  await manager.deleteTenant(tenant.id);

  console.log('Tenant removed:', slug);
}

npm install @node-tenant/tenant-core
npm install @node-tenant/tenant-mongoose
npm install mongoose  # peer dependency

// Step 1: User visits "acme.myapp.com"
//       │
//       ▼
// Step 2: TenantMiddleware sees "acme", sets the Global Context
//       │
//       ▼
// Step 3: You call useTenantModel('User', UserSchema) in your route
//       │
//       ├─► It asks the Context for the active customer ("acme")
//       │
//       ├─► It asks the Connection Pool for the "acme" connection
//       │
//       └─► Step 4: It returns a standard Mongoose Model permanently locked to "tenant_acme"!

// schemas/User.ts
import { Schema } from 'mongoose';

// 1. Define the shape of your data
export interface IUser {
  name: string;
  email: string;
  role: 'admin' | 'member';
  createdAt: Date;
}

// 2. Create the raw Mongoose Schema
// Notice we DO NOT call mongoose.model() here!
export const UserSchema = new Schema<IUser>({
  name:      { type: String, required: true },
  email:     { type: String, required: true, unique: true },
  role:      { type: String, enum: ['admin', 'member'], default: 'member' },
  createdAt: { type: Date, default: Date.now },
});

// All your normal Mongoose hooks, virtuals, and methods work perfectly
UserSchema.pre('save', function (next) {
  this.email = this.email.toLowerCase();
  next();
});

import express from 'express';
import { TenantManager } from '@node-tenant/tenant-core';
import { tenantMiddleware, subdomainResolver } from '@node-tenant/tenant-express';
import { createConnectionPool, useTenantModel } from '@node-tenant/tenant-mongoose';
import { UserSchema, IUser } from './schemas/User';

// 1. Create a Connection Pool
// This is like a factory that produces database connections when needed.
const getConnection = createConnectionPool(
  process.env.MONGODB_URI!,  
  'tenant_' // e.g. tenant_acme
);

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

// 2. Secure your app with the middleware
app.use(tenantMiddleware({ manager, resolver: subdomainResolver() }));

// 3. Write your routes
app.get('/api/users', async (req, res) => {
  // Magic! This automatically gives you the 'User' model for the active customer
  const User = useTenantModel<IUser>('User', UserSchema, getConnection);
  
  // It only fetches users from their database
  const users = await User.find({ role: 'member' });
  res.json(users);
});

app.post('/api/users', async (req, res) => {
  const User = useTenantModel<IUser>('User', UserSchema, getConnection);
  const user = new User(req.body);
  
  // Mongoose pre-save hooks will run normally!
  await user.save(); 
  res.status(201).json(user);
});

app.listen(3000);

import { useTenantConnection } from '@node-tenant/tenant-mongoose';

// Grab the raw Mongoose Connection for the active customer
const conn = useTenantConnection(getConnection);

// Bind multiple schemas at once
const User    = conn.model<IUser>('User', UserSchema);
const Product = conn.model<IProduct>('Product', ProductSchema);
const Order   = conn.model<IOrder>('Order', OrderSchema);

// Now use them normally!
const users    = await User.find();
const products = await Product.find({ inStock: true });

import { createMongoDBDatabaseAdapter } from '@node-tenant/tenant-mongodb';

const dbAdapter = createMongoDBDatabaseAdapter({ client: mongoClient });
const manager = new TenantManager({ storage, databaseAdapter: dbAdapter });

app.get('/api/orders', async (req, res) => {
  // It securely switches to tenant_acme, tenant_globex, etc. for you
  const db = await dbAdapter.switchTenant((req as any).tenant);
  const orders = await db.collection('orders').find({}).toArray();
  res.json(orders);
});

// No database adapter provided here!
const manager = new TenantManager({ storage }); 

app.get('/api/orders', async (req, res) => {
  const activeCustomer = (req as any).tenant;
  
  // DANGER: You MUST remember to include tenantId here, otherwise 
  // you will return everyone's orders to this customer!
  const orders = await masterDb.collection('orders').find({ tenantId: activeCustomer.id }).toArray();
  res.json(orders);
});

app.post('/api/orders', async (req, res) => {
  const activeCustomer = (req as any).tenant;
  // Always attach tenantId when saving new data
  await masterDb.collection('orders').insertOne({ ...req.body, tenantId: activeCustomer.id });
  res.status(201).send();
});

import { MongoClient } from 'mongodb';
import { TenantManager } from '@node-tenant/tenant-core';
import { createMongoDBDatabaseAdapter } from '@node-tenant/tenant-mongodb';
import {
  createConnectionPool,
  useTenantModel,
} from '@node-tenant/tenant-mongoose';

const mongoClient = new MongoClient(process.env.MONGODB_URI!);
await mongoClient.connect();

// tenant-mongodb handles lifecycle
const dbAdapter = createMongoDBDatabaseAdapter({ client: mongoClient });

// tenant-mongoose handles per-request query routing
const getConnection = createConnectionPool(process.env.MONGODB_URI!);

// --- TENANT PROVISIONING (use tenant-mongodb) ---
async function onNewCustomer(slug: string) {
  const tenant = await manager.createTenant({ slug });
  await dbAdapter.createTenantDatabase(tenant);  // ← tenant-mongodb
  await dbAdapter.seedTenant(tenant, async (db) => {
    await db.collection('settings').insertOne({ plan: 'free' });
  });
}

// --- PER-REQUEST QUERY (use tenant-mongoose) ---
app.get('/api/products', async (req, res) => {
  const Product = useTenantModel('Product', ProductSchema, getConnection); // ← tenant-mongoose
  const products = await Product.find({ active: true });
  res.json(products);
});