Documentation Portal

# Install the core engine (required for everything)
pnpm add @node-tenant/tenant-core

# Install the Express framework adapter (so we can intercept HTTP requests)
pnpm add @node-tenant/tenant-express

# Install the Prisma storage adapter (tells the system where to save tenant lists)
pnpm add @node-tenant/tenant-storage-prisma

# Install the Prisma ORM adapter (automatically filters database queries)
pnpm add @node-tenant/tenant-prisma

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

// 1. Initialize Database & Storage
const prisma = new PrismaClient();
const storage = createPrismaStorage(prisma);
const manager = new TenantManager({ storage });

// 2. Initialize Express App
const app = express();
app.use(express.json());

// 3. Register Tenant Middleware
// Resolves tenant from subdomain: customer1.myapp.com -> tenant slug "customer1"
app.use(tenantMiddleware({ manager, resolver: subdomainResolver(storage) }));

// 4. Create Protected Route
app.get('/api/users', async (req, res) => {
  // 5. Fetch Data
  const db = useTenantPrisma(prisma);
  const users = await db.user.findMany(); 
  res.json(users);
});

app.listen(3000, () => console.log('Server is running on port 3000'));

import { TenantManager } from '@node-tenant/tenant-core';
import { createPrismaStorage } from '@node-tenant/tenant-storage-prisma';
import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();
const storage = createPrismaStorage(prisma);

// We initialize the manager globally once.
const manager = new TenantManager({
  storage,
  auditEnabled: true // Logs every tenant creation, update, and deletion securely.
});

// Create a new tenant dynamically
const newTenant = await manager.createTenant({
  name: 'Acme Corp',
  slug: 'acme',
  strategy: 'tenantId', // They will share a database
  status: 'active',
  config: { plan: 'premium' } // Custom JSON data
});

import { TenantContextManager } from '@node-tenant/tenant-core';

// Retrieve the currently active tenant context anywhere in your app:
const context = TenantContextManager.current();
console.log(context.slug); // e.g., 'acme'

// Or intentionally run a block of code AS a specific tenant:
await manager.runAsTenant('acme', async () => {
  const currentCtx = TenantContextManager.currentOrThrow();
  // All database queries or business logic inside this callback 
  // automatically run under the 'acme' context.
});

// Subscribe to the 'tenant.created' event
manager.on('tenant.created', async (tenant) => {
  console.log(`Tenant ${tenant.name} was successfully created!`);
  // Example: await stripe.customers.create({ email: tenant.config.email });
});

// Subscribe to context switches (useful for advanced debugging)
manager.on('tenant.switched', ({ from, to }) => {
  console.log(`Context switched from ${from?.slug} to ${to.slug}`);
});

import express from 'express';
import { TenantManager } from '@node-tenant/tenant-core';
import { tenantMiddleware, headerResolver } from '@node-tenant/tenant-express';

const app = express();
const manager = new TenantManager({ storage });

// Scopes request contexts using the 'x-tenant-id' request header
app.use(tenantMiddleware({
  manager,
  resolver: headerResolver('x-tenant-id')
}));

// middleware.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';
import { withTenant, subdomainResolver } from '@node-tenant/tenant-next';

export default withTenant({
  resolver: subdomainResolver(),
  onSuccess: (req, context) => {
    return NextResponse.next();
  }
});

import { OrganizationManager } from '@node-tenant/tenant-organizations';

const orgManager = new OrganizationManager(manager);

// Create organization with an initial tenant
const { organization, tenant } = await orgManager.createWithTenant({
  orgName: 'Hireflow Corp',
  orgSlug: 'hireflow',
  tenantName: 'Hireflow USA',
  tenantSlug: 'hireflow-usa',
  strategy: 'tenantId'
});

import { TenantRelationshipManager } from '@node-tenant/tenant-relations';

const relManager = new TenantRelationshipManager(manager);

// Establish a bidirectional partnership relationship
await relManager.createBidirectional(tenantAId, tenantBId, 'partner', {
  purpose: 'Shared candidate pipeline'
});

// Check if tenantA is linked to tenantB as a partner
const isLinked = await relManager.hasRelationship(tenantAId, tenantBId, 'partner');

// Share a resource (e.g. a candidate profile)
await manager.shareResource({
  resourceType: 'Candidate',
  resourceId: 'cand_93019',
  ownerTenantId: tenantAId,
  targetTenantId: tenantBId,
  permission: 'read'
});

import { TenantRelationshipManager } from '@node-tenant/tenant-relations';
import { TenantManager } from '@node-tenant/tenant-core';

const manager = new TenantManager({ storage });
const relManager = new TenantRelationshipManager(manager);

// 1. Connect tenants during onboarding or setup:
await relManager.createBidirectional(
  'tenant-id-acme-usa', 
  'tenant-id-acme-uk', 
  'collaboration', 
  { connectedAt: new Date() }
);

// 2. Share a specific record (e.g., a candidate profile) across connected tenants:
const share = await manager.shareResource({
  resourceType: 'Candidate',
  resourceId: 'cand_84920',
  ownerTenantId: 'tenant-id-acme-usa',
  targetTenantId: 'tenant-id-acme-uk',
  permission: 'read'
});

// 3. The target tenant can query shared resources dynamically:
const sharedShares = await manager.getShares({
  targetTenantId: 'tenant-id-acme-uk',
  resourceType: 'Candidate'
});