Backend — Configuration

import { createConsenti } from '@consenti/api'
import http from 'node:http'

const consenti = createConsenti({
  storage: { driver: 'json', path: './consenti-data' },
  auth: {
    mode: 'local',
    adminEmail: '[email protected]',
    adminPassword: process.env.CONSENTI_ADMIN_PASSWORD!,
  },
  dashboard: true,
})

http.createServer(consenti.handler).listen(3001)
// Admin → http://localhost:3001/consenti/
// API   → http://localhost:3001/consenti/api/v1/

import { createConsenti } from '@consenti/api'

const consenti = createConsenti({
  // Optional but recommended
  storage: {
    driver: 'json',            // not recommended for production
    path: './consenti-data',   // directory path — Consenti creates db/, profiles/, logs/ inside
  },
  auth: {
    mode: 'local',
    adminEmail: process.env.CONSENTI_ADMIN_EMAIL ?? '[email protected]',
    adminPassword: process.env.CONSENTI_ADMIN_PASSWORD ?? 'Consenti@123',
    jwtSecret: process.env.CONSENTI_ADMIN_JWT_SECRET ?? 'random-jwt-secret',
  },

  // Optional
  basePath: '/consenti',       // URL prefix for all routes
  dashboard: true,             // serve admin SPA at basePath

  rateLimit: {
    windowMs: 60_000,          // 1-minute window
    maxRequests: 60,           // requests per window per IP
  },

  compliance: {
    type: 'auto',                 // 'auto' = geo-resolve per visitor | ComplianceGroupId = fixed group
    geoDataProvider: 'default',   // 'default' | 'hosted-geoip-lite' | 'geoip' | 'maxmind' | CountryResolverFn
    autoComplianceMap: 'default', // 'default' (embedded 240-country map) | object | 'auto' (remote URL)
  },

  // S3 sync for profile locale JSON files (optional)
  s3Api: {
    enabled: false,
    region: 'us-east-1',
    bucketName: 'consenti-profiles',
    accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,
    // sessionToken: process.env.AWS_SESSION_TOKEN,  // for temporary credentials
  },

  // CDN / cache invalidation hook (optional)
  handleCache: (paths, version, isPurge) => {
    // paths: locale file paths written or removed
    // isPurge: true = files removed (deactivate/delete); false = files written (create/activate)
  },

  tcf: {
    enabled: false,
    cmpId: 0,
    cmpVersion: 1,
  },

  ageGate: {
    enabled: false,
    minimumAge: 13,
    requireParentalConsent: false,
  },

  dataRetention: {
    purgeAfterDays: 365,       // delete consent records older than this
  },

  multiTenant: {
    enabled: false,
  },

  maxBodySize: 1_048_576,      // 1 MB request body limit
  trustedProxies: [],          // IPs / CIDRs of reverse proxies (nginx, Cloudflare…)

  branding: {
    appName: 'My CMP',         // dashboard header, login page, browser tab
    appLogoPath: './logo.svg', // local file or https:// URL
    hidePoweredBy: false,      // true = hide "Powered by Consenti" badge
  },

  plugins: [],
})

${storage.path}/
  db/
    consenti-data.json     ← JSON adapter
    consenti.db            ← SQLite adapters
  profiles/
    ${tenantId}/
      ${profileId}/
        1/                 ← version 1 (immutable once written)
          en.json
          fr-FR.json
          default.json     ← copy of defaultLocale content
        2/                 ← version 2 on next edit
      ${complianceGroup}/ ← hot-serve path (active profile only)
        en.json
        fr-FR.json
        default.json
  logs/                    ← reserved for future use

storage: { driver: 'json', path: './consenti-data' } // path is a directory

# Node 20+ native addon (fastest; needs build toolchain or prebuilt binary)
npm install better-sqlite3

# Node 20+ WASM fallback (no compilation required)
npm install node-sqlite3-wasm

// Node 22.5+ — built-in, no install needed
storage: { driver: 'node:sqlite', path: './consenti.db' }

// Node 20+ with native addon
storage: { driver: 'better-sqlite3', path: './consenti.db' }

// Node 20+ WASM fallback
storage: { driver: 'node-sqlite3-wasm', path: './consenti.db' }

npm install pg         # PostgreSQL
npm install mysql2     # MySQL / MariaDB
npm install mongodb    # MongoDB

// PostgreSQL
storage: { driver: 'postgresql', uri: process.env.CONSENTI_DATABASE_URL }

// MySQL
storage: { driver: 'mysql', uri: process.env.CONSENTI_DATABASE_URL }

// MongoDB
storage: { driver: 'mongodb', uri: process.env.CONSENTI_DATABASE_URL, database: 'consenti' }

auth: {
  mode: 'local',
  adminEmail: '[email protected]',
  adminPassword: process.env.CONSENTI_ADMIN_PASSWORD!, // min 12 chars; 16+ recommended
  jwtSecret: process.env.CONSENTI_ADMIN_JWT_SECRET!,         // stable secret for production
}

auth: {
  mode: 'jwt',
  jwtSecret: process.env.CONSENTI_ADMIN_JWT_SECRET!, // must match the secret used to sign your tokens
}

{
  "sub": "user-id",
  "email": "[email protected]",
  "roles": ["super_admin"],
  "tenantId": "default"
}

auth: {
  mode: 'oidc',
  jwtSecret: process.env.CONSENTI_ADMIN_JWT_SECRET!, // signs the session cookie after OIDC login
  oidc: {
    issuer: 'https://accounts.google.com',  // or any OIDC-compliant provider
    clientId: process.env.OIDC_CLIENT_ID!,
    clientSecret: process.env.OIDC_CLIENT_SECRET!,
    redirectUri: 'https://yourapp.com/consenti/auth/oidc/callback',
    claimsMapping: {
      email: 'email',           // default; override if your IdP uses a different claim
      roles: 'consenti_roles',  // default; the claim that carries Consenti role names
    },
  },
}

npm install samlify

auth: {
  mode: 'saml',
  jwtSecret: process.env.CONSENTI_ADMIN_JWT_SECRET!,
  saml: {
    issuer: 'https://idp.example.com',
    entryPoint: 'https://idp.example.com/sso/saml',  // IdP SSO URL
    cert: process.env.IDP_CERT!,                      // IdP signing certificate (PEM, without headers)
    callbackUrl: 'https://yourapp.com/consenti/auth/saml/callback',
  },
}

import type { AdminUser } from '@consenti/types'

auth: {
  mode: 'custom',
  validateUser: async (req: Request): Promise<AdminUser | null> => {
    const token = req.headers.get('authorization')?.replace('Bearer ', '')
    if (!token) return null

    // call your own auth service, validate a session cookie, etc.
    const user = await myAuthService.verifyToken(token)
    if (!user) return null

    return {
      id: user.id,
      tenantId: 'default',
      name: user.name,
      email: user.email,
      passwordHash: '',
      isActive: true,
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    }
  },
}

import {
  generateTotpSecret,
  totpQrUrl,
  verifyTotp,
} from '@consenti/api'

// 1. Generate and persist a secret per user
const secret = generateTotpSecret() // base32 string

// 2. Show the QR code to the user during setup
const otpauthUrl = totpQrUrl(secret, '[email protected]', 'MyApp')
// → otpauth://totp/MyApp:admin%40example.com?secret=...

// 3. Verify a submitted 6-digit code (window = ±1 time-step)
const ok = verifyTotp(secret, submittedCode)

// Default — routes at /consenti/api/v1/...
basePath: '/consenti'

// Custom prefix
basePath: '/cmp'
// → public API:  /cmp/api/v1/consent
// → admin API:   /cmp/admin/...
// → dashboard:   /cmp  (SPA)
// → OpenAPI UI:  /cmp/api/docs

// Simplest — serve at /consenti
dashboard: true

// Disable (headless / API-only mode)
dashboard: false

// Serve at a custom path
dashboard: { enabled: true, path: '/admin' }

// Tighter limit for high-traffic sites
rateLimit: {
  windowMs: 60_000,    // 1-minute window
  maxRequests: 30,     // 30 req/min per IP
}

// Disable entirely (you handle rate limiting upstream)
rateLimit: { enabled: false }

// Zero-dep geo routing (timezone + Accept-Language heuristic)
compliance: {
  type: 'auto',
  geoDataProvider: 'default',
  autoComplianceMap: 'default',
}

// IP-based — no install, calls ipinfo.io (requires outbound internet)
compliance: {
  type: 'auto',
  geoDataProvider: 'hosted-geoip-lite',
}

// IP-based — local lookup via geoip-lite (npm install geoip-lite)
compliance: {
  type: 'auto',
  geoDataProvider: 'geoip',
}

// Fixed group — GDPR-only product serving only EU visitors
compliance: {
  type: 'opt-in',
}

// Custom geo resolver — integrate your own GeoIP SaaS
compliance: {
  type: 'auto',
  geoDataProvider: async ({ ip, timezone, language }) => {
    const res = await fetch(`https://api.mygeoip.com/${ip}`)
    const data = await res.json()
    return { country: data.country_code, region: data.region, locale: data.locale ?? null }
  },
}

s3Api: {
  enabled: true,
  region: 'us-east-1',
  bucketName: 'my-cmp-profiles',
  accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
  secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,
}

handleCache: (paths, version, isPurge) => {
  if (isPurge) {
    // Purge these paths from your CDN / nginx proxy cache
    for (const p of paths) {
      cdnClient.purge(p)
    }
  } else {
    // Warm the cache at these paths
    for (const p of paths) {
      cdnClient.warm(p)
    }
  }
}

tcf: {
  enabled: true,
  cmpId: 42,        // your IAB CMP ID
  cmpVersion: 1,
}

// COPPA — block users under 13
ageGate: {
  enabled: true,
  minimumAge: 13,
}

// GDPR Article 8 — require parental consent for users 13–15
ageGate: {
  enabled: true,
  minimumAge: 16,
  requireParentalConsent: true,
}

// Keep consent records for 1 year, then purge automatically
dataRetention: {
  purgeAfterDays: 365,
}

multiTenant: { enabled: true }

// Clients must then pass:
// X-Tenant-ID: acme-corp
// or: GET /consenti/api/v1/consent?tenantId=acme-corp

maxBodySize: 512_000   // 512 KB

// Single proxy
trustedProxies: ['127.0.0.1']

// Private network (e.g. Kubernetes cluster)
trustedProxies: ['10.0.0.0/8', '172.16.0.0/12', '192.168.0.0/16']

import {
  ConsentiServerPlugin,
  type PluginContext,
  type CreateConsentInput,
  type ConsentDbRecord,
} from '@consenti/api'

export class AuditWebhookPlugin extends ConsentiServerPlugin {
  name = 'audit-webhook'

  async initialize(ctx: PluginContext): Promise<void> {
    // ctx.storage — direct StorageAdapter access
    // ctx.config  — full ConsentiServerConfig
    console.log('AuditWebhookPlugin ready')
  }

  async afterConsentSave(record: ConsentDbRecord): Promise<void> {
    await fetch('https://webhook.example.com/consent', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(record),
    })
  }

  async destroy(): Promise<void> {
    // clean up connections, timers, etc.
  }
}

// Register it:
plugins: [new AuditWebhookPlugin()]

// Minimal — just change the app name
branding: {
  appName: 'Acme CMP',
}

// Full white-label — custom name, logo, and hide badge
branding: {
  appName: 'Acme CMP',
  appLogoPath: './assets/acme-logo.svg',  // local file — copied and served automatically
  hidePoweredBy: true,
}

// Logo from a public CDN
branding: {
  appName: 'Acme CMP',
  appLogoPath: 'https://cdn.acme.com/logo.svg',
}