dartmind 17.0.0

package/dist/whitelabel/tenant-manager.js

@@ -0,0 +1,663 @@
+/**
+ * FlutterAI V16 - Tenant Manager
+ *
+ * Multi-tenant management with lifecycle controls.
+ *
+ * @module whitelabel/tenant-manager
+ * @version 16.0.0
+ */
+import { EventEmitter } from 'events';
+import { createDefaultFeatures, createDefaultRateLimits, createDefaultQuotas, createDefaultBranding, } from './types.js';
+/**
+ * In-memory tenant storage
+ */
+export class MemoryTenantStorage {
+    tenants = new Map();
+    slugIndex = new Map();
+    domainIndex = new Map();
+    async get(id) {
+        return this.tenants.get(id) || null;
+    }
+    async getBySlug(slug) {
+        const id = this.slugIndex.get(slug);
+        return id ? (this.tenants.get(id) || null) : null;
+    }
+    async getByDomain(domain) {
+        const id = this.domainIndex.get(domain.toLowerCase());
+        return id ? (this.tenants.get(id) || null) : null;
+    }
+    async save(tenant) {
+        // Remove old indexes
+        const existing = this.tenants.get(tenant.id);
+        if (existing) {
+            this.slugIndex.delete(existing.slug);
+            if (existing.domain) {
+                this.domainIndex.delete(existing.domain.toLowerCase());
+            }
+            for (const d of existing.customDomains) {
+                this.domainIndex.delete(d.domain.toLowerCase());
+            }
+        }
+        // Save tenant
+        this.tenants.set(tenant.id, tenant);
+        // Update indexes
+        this.slugIndex.set(tenant.slug, tenant.id);
+        if (tenant.domain) {
+            this.domainIndex.set(tenant.domain.toLowerCase(), tenant.id);
+        }
+        for (const d of tenant.customDomains) {
+            if (d.status === 'active' || d.status === 'verified') {
+                this.domainIndex.set(d.domain.toLowerCase(), tenant.id);
+            }
+        }
+    }
+    async delete(id) {
+        const tenant = this.tenants.get(id);
+        if (tenant) {
+            this.slugIndex.delete(tenant.slug);
+            if (tenant.domain) {
+                this.domainIndex.delete(tenant.domain.toLowerCase());
+            }
+            for (const d of tenant.customDomains) {
+                this.domainIndex.delete(d.domain.toLowerCase());
+            }
+            this.tenants.delete(id);
+        }
+    }
+    async list(options) {
+        let tenants = Array.from(this.tenants.values());
+        // Filter by status
+        if (options.status) {
+            tenants = tenants.filter((t) => t.status === options.status);
+        }
+        // Filter by tier
+        if (options.tier) {
+            tenants = tenants.filter((t) => t.tier === options.tier);
+        }
+        // Search
+        if (options.search) {
+            const search = options.search.toLowerCase();
+            tenants = tenants.filter((t) => t.name.toLowerCase().includes(search) ||
+                t.slug.toLowerCase().includes(search) ||
+                t.contactEmail.toLowerCase().includes(search));
+        }
+        // Sort
+        const sortBy = options.sortBy || 'createdAt';
+        const sortOrder = options.sortOrder || 'desc';
+        tenants.sort((a, b) => {
+            const aVal = a[sortBy];
+            const bVal = b[sortBy];
+            if (aVal instanceof Date && bVal instanceof Date) {
+                return sortOrder === 'asc'
+                    ? aVal.getTime() - bVal.getTime()
+                    : bVal.getTime() - aVal.getTime();
+            }
+            if (typeof aVal === 'string' && typeof bVal === 'string') {
+                return sortOrder === 'asc' ? aVal.localeCompare(bVal) : bVal.localeCompare(aVal);
+            }
+            return 0;
+        });
+        // Paginate
+        const page = options.page || 1;
+        const limit = options.limit || 20;
+        const start = (page - 1) * limit;
+        const paginatedTenants = tenants.slice(start, start + limit);
+        return {
+            tenants: paginatedTenants,
+            total: tenants.length,
+            page,
+            limit,
+            hasMore: start + limit < tenants.length,
+        };
+    }
+    async getUsage(id, period) {
+        return {
+            tenantId: id,
+            period,
+            requests: 0,
+            aiRequests: 0,
+            tokensUsed: 0,
+            storageUsed: 0,
+            usersActive: 0,
+            projectsCreated: 0,
+            generationsCreated: 0,
+        };
+    }
+}
+// ============================================================================
+// TENANT MANAGER
+// ============================================================================
+/**
+ * Tenant manager for multi-tenant operations
+ */
+export class TenantManager extends EventEmitter {
+    storage;
+    cache = new Map();
+    cacheTtl;
+    enableCache;
+    resolutionStrategy;
+    constructor(options = {}) {
+        super();
+        this.storage = options.storage || new MemoryTenantStorage();
+        this.enableCache = options.enableCache ?? true;
+        this.cacheTtl = options.cacheTtl ?? 60000; // 1 minute
+        this.resolutionStrategy = options.defaultResolutionStrategy ?? 'subdomain';
+    }
+    // ==========================================================================
+    // TENANT LIFECYCLE
+    // ==========================================================================
+    /**
+     * Create a new tenant
+     */
+    async createTenant(request) {
+        // Validate slug uniqueness
+        const existingSlug = await this.storage.getBySlug(request.slug);
+        if (existingSlug) {
+            throw new Error(`Tenant with slug "${request.slug}" already exists`);
+        }
+        const tier = request.tier || 'free';
+        const now = new Date();
+        const tenant = {
+            id: this.generateTenantId(),
+            name: request.name,
+            slug: request.slug,
+            status: 'active',
+            tier,
+            customDomains: [],
+            branding: request.branding
+                ? { ...createDefaultBranding(request.name), ...request.branding }
+                : createDefaultBranding(request.name),
+            features: request.features
+                ? { ...createDefaultFeatures(tier), ...request.features }
+                : createDefaultFeatures(tier),
+            rateLimits: createDefaultRateLimits(tier),
+            quotas: createDefaultQuotas(tier),
+            metadata: request.metadata || {},
+            contactEmail: request.contactEmail,
+            createdAt: now,
+            updatedAt: now,
+        };
+        // Set trial if free tier
+        if (tier === 'free') {
+            tenant.trialEndsAt = new Date(now.getTime() + 14 * 24 * 60 * 60 * 1000); // 14 days
+        }
+        await this.storage.save(tenant);
+        this.emitEvent({ type: 'tenant:created', tenant });
+        return tenant;
+    }
+    /**
+     * Update tenant configuration
+     */
+    async updateTenant(id, updates) {
+        const tenant = await this.getTenant(id);
+        if (!tenant) {
+            throw new Error(`Tenant not found: ${id}`);
+        }
+        const changes = {};
+        // Apply updates
+        if (updates.name !== undefined) {
+            tenant.name = updates.name;
+            changes.name = updates.name;
+        }
+        if (updates.status !== undefined) {
+            tenant.status = updates.status;
+            changes.status = updates.status;
+        }
+        if (updates.tier !== undefined && updates.tier !== tenant.tier) {
+            tenant.tier = updates.tier;
+            changes.tier = updates.tier;
+            // Update defaults for new tier if not explicitly set
+            if (!updates.features) {
+                tenant.features = {
+                    ...createDefaultFeatures(updates.tier),
+                    ...tenant.features,
+                };
+            }
+            if (!updates.rateLimits) {
+                tenant.rateLimits = createDefaultRateLimits(updates.tier);
+            }
+            if (!updates.quotas) {
+                tenant.quotas = createDefaultQuotas(updates.tier);
+            }
+        }
+        if (updates.branding) {
+            tenant.branding = { ...tenant.branding, ...updates.branding };
+            changes.branding = tenant.branding;
+        }
+        if (updates.features) {
+            tenant.features = { ...tenant.features, ...updates.features };
+            changes.features = tenant.features;
+        }
+        if (updates.rateLimits) {
+            tenant.rateLimits = { ...tenant.rateLimits, ...updates.rateLimits };
+            changes.rateLimits = tenant.rateLimits;
+        }
+        if (updates.quotas) {
+            tenant.quotas = { ...tenant.quotas, ...updates.quotas };
+            changes.quotas = tenant.quotas;
+        }
+        if (updates.metadata) {
+            tenant.metadata = { ...tenant.metadata, ...updates.metadata };
+            changes.metadata = tenant.metadata;
+        }
+        if (updates.contactEmail !== undefined) {
+            tenant.contactEmail = updates.contactEmail;
+            changes.contactEmail = updates.contactEmail;
+        }
+        if (updates.technicalContact !== undefined) {
+            tenant.technicalContact = updates.technicalContact;
+        }
+        if (updates.billingEmail !== undefined) {
+            tenant.billingEmail = updates.billingEmail;
+        }
+        tenant.updatedAt = new Date();
+        await this.storage.save(tenant);
+        this.invalidateCache(id);
+        this.emitEvent({ type: 'tenant:updated', tenant, changes });
+        return tenant;
+    }
+    /**
+     * Delete a tenant
+     */
+    async deleteTenant(id) {
+        const tenant = await this.getTenant(id);
+        if (!tenant) {
+            throw new Error(`Tenant not found: ${id}`);
+        }
+        await this.storage.delete(id);
+        this.invalidateCache(id);
+        this.emitEvent({ type: 'tenant:deleted', tenantId: id });
+    }
+    /**
+     * Suspend a tenant
+     */
+    async suspendTenant(id, reason) {
+        const tenant = await this.updateTenant(id, { status: 'suspended' });
+        this.emitEvent({ type: 'tenant:suspended', tenantId: id, reason });
+        return tenant;
+    }
+    /**
+     * Activate a tenant
+     */
+    async activateTenant(id) {
+        const tenant = await this.updateTenant(id, { status: 'active' });
+        this.emitEvent({ type: 'tenant:activated', tenantId: id });
+        return tenant;
+    }
+    // ==========================================================================
+    // TENANT RETRIEVAL
+    // ==========================================================================
+    /**
+     * Get tenant by ID
+     */
+    async getTenant(id) {
+        // Check cache
+        if (this.enableCache) {
+            const cached = this.cache.get(`id:${id}`);
+            if (cached && cached.expires > Date.now()) {
+                return cached.tenant;
+            }
+        }
+        const tenant = await this.storage.get(id);
+        if (tenant && this.enableCache) {
+            this.cache.set(`id:${id}`, {
+                tenant,
+                expires: Date.now() + this.cacheTtl,
+            });
+        }
+        return tenant;
+    }
+    /**
+     * Get tenant by slug
+     */
+    async getTenantBySlug(slug) {
+        if (this.enableCache) {
+            const cached = this.cache.get(`slug:${slug}`);
+            if (cached && cached.expires > Date.now()) {
+                return cached.tenant;
+            }
+        }
+        const tenant = await this.storage.getBySlug(slug);
+        if (tenant && this.enableCache) {
+            this.cache.set(`slug:${slug}`, {
+                tenant,
+                expires: Date.now() + this.cacheTtl,
+            });
+        }
+        return tenant;
+    }
+    /**
+     * Get tenant by domain
+     */
+    async getTenantByDomain(domain) {
+        const normalizedDomain = domain.toLowerCase();
+        if (this.enableCache) {
+            const cached = this.cache.get(`domain:${normalizedDomain}`);
+            if (cached && cached.expires > Date.now()) {
+                return cached.tenant;
+            }
+        }
+        const tenant = await this.storage.getByDomain(normalizedDomain);
+        if (tenant && this.enableCache) {
+            this.cache.set(`domain:${normalizedDomain}`, {
+                tenant,
+                expires: Date.now() + this.cacheTtl,
+            });
+        }
+        return tenant;
+    }
+    /**
+     * List tenants
+     */
+    async listTenants(options = {}) {
+        return this.storage.list(options);
+    }
+    // ==========================================================================
+    // TENANT RESOLUTION
+    // ==========================================================================
+    /**
+     * Resolve tenant from request
+     */
+    async resolveTenant(request) {
+        const strategy = request.strategy || this.resolutionStrategy;
+        switch (strategy) {
+            case 'domain':
+                if (request.hostname) {
+                    return this.getTenantByDomain(request.hostname);
+                }
+                break;
+            case 'subdomain':
+                if (request.hostname) {
+                    const subdomain = this.extractSubdomain(request.hostname);
+                    if (subdomain) {
+                        return this.getTenantBySlug(subdomain);
+                    }
+                }
+                break;
+            case 'header':
+                if (request.headers?.['x-tenant-id']) {
+                    return this.getTenant(request.headers['x-tenant-id']);
+                }
+                if (request.headers?.['x-tenant-slug']) {
+                    return this.getTenantBySlug(request.headers['x-tenant-slug']);
+                }
+                break;
+            case 'path':
+                if (request.path) {
+                    const slug = this.extractPathSlug(request.path);
+                    if (slug) {
+                        return this.getTenantBySlug(slug);
+                    }
+                }
+                break;
+            case 'token':
+                if (request.token) {
+                    const tenantId = this.extractTenantFromToken(request.token);
+                    if (tenantId) {
+                        return this.getTenant(tenantId);
+                    }
+                }
+                break;
+        }
+        return null;
+    }
+    /**
+     * Extract subdomain from hostname
+     */
+    extractSubdomain(hostname) {
+        const parts = hostname.split('.');
+        if (parts.length >= 3) {
+            return parts[0];
+        }
+        return null;
+    }
+    /**
+     * Extract slug from path
+     */
+    extractPathSlug(path) {
+        const match = path.match(/^\/t\/([^/]+)/);
+        return match ? match[1] : null;
+    }
+    /**
+     * Extract tenant ID from token
+     */
+    extractTenantFromToken(token) {
+        try {
+            // Simple JWT decode (no verification - that's done elsewhere)
+            const parts = token.split('.');
+            if (parts.length === 3) {
+                const payload = JSON.parse(Buffer.from(parts[1], 'base64').toString());
+                return payload.tenantId || payload.tenant_id || null;
+            }
+        }
+        catch {
+            // Invalid token format
+        }
+        return null;
+    }
+    // ==========================================================================
+    // DOMAIN MANAGEMENT
+    // ==========================================================================
+    /**
+     * Add custom domain
+     */
+    async addDomain(tenantId, request) {
+        const tenant = await this.getTenant(tenantId);
+        if (!tenant) {
+            throw new Error(`Tenant not found: ${tenantId}`);
+        }
+        // Check quota
+        if (tenant.quotas.maxCustomDomains !== -1 &&
+            tenant.customDomains.length >= tenant.quotas.maxCustomDomains) {
+            throw new Error('Maximum custom domains reached');
+        }
+        // Check if domain already exists
+        const existingTenant = await this.getTenantByDomain(request.domain);
+        if (existingTenant) {
+            throw new Error(`Domain "${request.domain}" is already in use`);
+        }
+        const domain = {
+            domain: request.domain.toLowerCase(),
+            status: 'pending',
+            sslStatus: 'pending',
+            dnsVerification: this.generateDnsVerification(request.domain),
+            isPrimary: request.isPrimary ?? false,
+            createdAt: new Date(),
+        };
+        // If setting as primary, unset other primaries
+        if (domain.isPrimary) {
+            tenant.customDomains.forEach((d) => (d.isPrimary = false));
+        }
+        tenant.customDomains.push(domain);
+        tenant.updatedAt = new Date();
+        await this.storage.save(tenant);
+        this.invalidateCache(tenantId);
+        this.emitEvent({ type: 'domain:added', tenantId, domain });
+        return domain;
+    }
+    /**
+     * Remove custom domain
+     */
+    async removeDomain(tenantId, domain) {
+        const tenant = await this.getTenant(tenantId);
+        if (!tenant) {
+            throw new Error(`Tenant not found: ${tenantId}`);
+        }
+        const domainIndex = tenant.customDomains.findIndex((d) => d.domain.toLowerCase() === domain.toLowerCase());
+        if (domainIndex === -1) {
+            throw new Error(`Domain "${domain}" not found`);
+        }
+        tenant.customDomains.splice(domainIndex, 1);
+        tenant.updatedAt = new Date();
+        await this.storage.save(tenant);
+        this.invalidateCache(tenantId);
+        this.emitEvent({ type: 'domain:removed', tenantId, domain });
+    }
+    /**
+     * Verify custom domain
+     */
+    async verifyDomain(tenantId, domain) {
+        const tenant = await this.getTenant(tenantId);
+        if (!tenant) {
+            throw new Error(`Tenant not found: ${tenantId}`);
+        }
+        const customDomain = tenant.customDomains.find((d) => d.domain.toLowerCase() === domain.toLowerCase());
+        if (!customDomain) {
+            throw new Error(`Domain "${domain}" not found`);
+        }
+        // Perform DNS verification
+        const verified = await this.performDnsVerification(customDomain);
+        if (verified) {
+            customDomain.status = 'verified';
+            customDomain.dnsVerification.verified = true;
+            customDomain.dnsVerification.lastChecked = new Date();
+            customDomain.verifiedAt = new Date();
+            tenant.updatedAt = new Date();
+            await this.storage.save(tenant);
+            this.invalidateCache(tenantId);
+            this.emitEvent({ type: 'domain:verified', tenantId, domain });
+        }
+        else {
+            customDomain.dnsVerification.lastChecked = new Date();
+            await this.storage.save(tenant);
+        }
+        return verified;
+    }
+    /**
+     * Generate DNS verification record
+     */
+    generateDnsVerification(domain) {
+        const verificationCode = this.generateVerificationCode();
+        return {
+            type: 'TXT',
+            name: `_flutterai-verify.${domain}`,
+            value: `flutterai-verification=${verificationCode}`,
+            verified: false,
+        };
+    }
+    /**
+     * Perform DNS verification
+     */
+    async performDnsVerification(domain) {
+        // In production, this would query DNS records
+        // For now, simulate verification
+        try {
+            const { promises: dns } = await import('dns');
+            const records = await dns.resolveTxt(domain.dnsVerification.name);
+            const flatRecords = records.flat();
+            return flatRecords.some((r) => r === domain.dnsVerification.value);
+        }
+        catch {
+            // DNS lookup failed
+            return false;
+        }
+    }
+    // ==========================================================================
+    // BRANDING
+    // ==========================================================================
+    /**
+     * Update tenant branding
+     */
+    async updateBranding(tenantId, branding) {
+        const tenant = await this.updateTenant(tenantId, { branding });
+        this.emitEvent({ type: 'branding:updated', tenantId, branding: tenant.branding });
+        return tenant.branding;
+    }
+    // ==========================================================================
+    // USAGE & QUOTAS
+    // ==========================================================================
+    /**
+     * Get tenant usage
+     */
+    async getUsage(tenantId, period = 'month') {
+        return this.storage.getUsage(tenantId, period);
+    }
+    /**
+     * Check quota
+     */
+    async checkQuota(tenantId, quota, current) {
+        const tenant = await this.getTenant(tenantId);
+        if (!tenant) {
+            throw new Error(`Tenant not found: ${tenantId}`);
+        }
+        const limit = tenant.quotas[quota];
+        // -1 means unlimited
+        if (limit === -1) {
+            return { allowed: true, limit: -1, remaining: -1 };
+        }
+        const remaining = limit - current;
+        const allowed = remaining > 0;
+        if (!allowed) {
+            this.emitEvent({
+                type: 'quota:exceeded',
+                tenantId,
+                quota,
+                current,
+                limit,
+            });
+        }
+        return { allowed, limit, remaining };
+    }
+    // ==========================================================================
+    // UTILITIES
+    // ==========================================================================
+    /**
+     * Generate tenant ID
+     */
+    generateTenantId() {
+        const timestamp = Date.now().toString(36);
+        const random = Math.random().toString(36).substring(2, 10);
+        return `tn_${timestamp}${random}`;
+    }
+    /**
+     * Generate verification code
+     */
+    generateVerificationCode() {
+        return Array.from({ length: 32 }, () => Math.random().toString(36).charAt(2)).join('');
+    }
+    /**
+     * Invalidate cache entry
+     */
+    invalidateCache(tenantId) {
+        // Clear all possible cache keys for this tenant
+        for (const key of this.cache.keys()) {
+            const cached = this.cache.get(key);
+            if (cached && cached.tenant.id === tenantId) {
+                this.cache.delete(key);
+            }
+        }
+    }
+    /**
+     * Clear entire cache
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+    /**
+     * Emit tenant event
+     */
+    emitEvent(event) {
+        this.emit(event.type, event);
+        this.emit('tenant:event', event);
+    }
+    /**
+     * Subscribe to events
+     */
+    onEvent(handler) {
+        const listener = (event) => {
+            void handler(event);
+        };
+        this.on('tenant:event', listener);
+        return () => this.off('tenant:event', listener);
+    }
+}
+// ============================================================================
+// FACTORY
+// ============================================================================
+/**
+ * Create tenant manager
+ */
+export function createTenantManager(options) {
+    return new TenantManager(options);
+}
+//# sourceMappingURL=tenant-manager.js.map