@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/enterprise/billing.js

@@ -0,0 +1,512 @@
+/**
+ * Enterprise Billing - Subscription management and usage tracking.
+ *
+ * Embedded replacement for services/billing-service.
+ * All business logic is preserved verbatim from:
+ *   - services/billing-service/src/routes/subscriptions.ts
+ *   - services/billing-service/src/routes/usage.ts
+ *
+ * HTTP handlers, routes, and per-service SQLite are stripped.
+ * State is read/written through the unified database via ../state/billing.
+ */
+import { createSubscription as stateCreateSubscription, getSubscription as stateGetSubscription, updateSubscription as stateUpdateSubscription, recordUsage as stateRecordUsage, getUsage as stateGetUsage, getUsageSummary as stateGetUsageSummary, } from '../state/billing';
+const PLAN_CATALOG = {
+    free: {
+        name: 'Nimbus Free',
+        stripe_price_id: 'price_demo_free_monthly',
+        amount_cents: 0,
+        currency: 'usd',
+        interval: 'month',
+        seats_included: 5,
+        features: [
+            '5 team members',
+            '100K tokens/month',
+            'Community support',
+            'Basic Terraform generation',
+        ],
+    },
+    pro: {
+        name: 'Nimbus Pro',
+        stripe_price_id: 'price_demo_pro_monthly',
+        amount_cents: 4900,
+        currency: 'usd',
+        interval: 'month',
+        seats_included: 25,
+        features: [
+            '25 team members',
+            '5M tokens/month',
+            'Priority support',
+            'Multi-cloud generation',
+            'Drift detection',
+            'Cost optimization',
+            'Helm & K8s generation',
+        ],
+    },
+    enterprise: {
+        name: 'Nimbus Enterprise',
+        stripe_price_id: 'price_demo_enterprise_monthly',
+        amount_cents: 19900,
+        currency: 'usd',
+        interval: 'month',
+        seats_included: 100,
+        features: [
+            'Unlimited team members',
+            'Unlimited tokens',
+            'Dedicated support & SLA',
+            'SSO / SAML integration',
+            'Audit log export',
+            'Custom policy engine',
+            'Private deployment option',
+            'Advanced RBAC',
+        ],
+    },
+};
+const VALID_PLANS = ['free', 'pro', 'enterprise'];
+const PLAN_QUOTAS = {
+    free: {
+        tokensPerMonth: 100_000,
+        operationsPerMonth: 500,
+        costCapUsd: 0,
+    },
+    pro: {
+        tokensPerMonth: 5_000_000,
+        operationsPerMonth: 25_000,
+        costCapUsd: 100,
+    },
+    enterprise: {
+        tokensPerMonth: -1, // unlimited
+        operationsPerMonth: -1,
+        costCapUsd: -1,
+    },
+};
+// ---------------------------------------------------------------------------
+// Private helpers
+// ---------------------------------------------------------------------------
+/**
+ * Generate a random alphanumeric demo ID of the given length.
+ * Preserved verbatim from billing-service/src/db/adapter.ts.
+ */
+function generateDemoId(length) {
+    const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+}
+/**
+ * Build a realistic Stripe-format subscription object for demo presentations.
+ * Preserved verbatim from billing-service/src/routes/subscriptions.ts.
+ */
+function buildStripeSubscription(teamId, plan, stripeSubId, stripeCustomerId, periodStart, periodEnd, seats, canceled = false, canceledAt = null) {
+    const planDetails = PLAN_CATALOG[plan] || PLAN_CATALOG.pro;
+    const createdTimestamp = Math.floor((periodStart.getTime() - 5000) / 1000);
+    const periodStartUnix = Math.floor(periodStart.getTime() / 1000);
+    const periodEndUnix = Math.floor(periodEnd.getTime() / 1000);
+    const invoiceId = `in_demo_${generateDemoId(24)}`;
+    const invoiceNumber = `NIM-${periodStart.getFullYear()}${String(periodStart.getMonth() + 1).padStart(2, '0')}-${String(Math.floor(Math.random() * 9999) + 1).padStart(4, '0')}`;
+    const seatAmount = planDetails.amount_cents * seats;
+    return {
+        id: stripeSubId,
+        object: 'subscription',
+        customer: stripeCustomerId,
+        status: canceled ? 'canceled' : 'active',
+        current_period_start: periodStartUnix,
+        current_period_end: periodEndUnix,
+        created: createdTimestamp,
+        cancel_at_period_end: canceled,
+        canceled_at: canceledAt ? Math.floor(canceledAt.getTime() / 1000) : null,
+        plan: {
+            id: planDetails.stripe_price_id,
+            object: 'plan',
+            product: `prod_demo_nimbus_${plan}`,
+            nickname: planDetails.name,
+            amount: planDetails.amount_cents,
+            currency: planDetails.currency,
+            interval: planDetails.interval,
+            interval_count: 1,
+            active: true,
+        },
+        items: {
+            object: 'list',
+            data: [
+                {
+                    id: `si_demo_${generateDemoId(14)}`,
+                    object: 'subscription_item',
+                    price: {
+                        id: planDetails.stripe_price_id,
+                        object: 'price',
+                        unit_amount: planDetails.amount_cents,
+                        currency: planDetails.currency,
+                        recurring: { interval: planDetails.interval, interval_count: 1 },
+                        product: `prod_demo_nimbus_${plan}`,
+                    },
+                    quantity: seats,
+                },
+            ],
+            total_count: 1,
+        },
+        latest_invoice: {
+            id: invoiceId,
+            object: 'invoice',
+            number: invoiceNumber,
+            status: 'paid',
+            amount_due: seatAmount,
+            amount_paid: seatAmount,
+            currency: planDetails.currency,
+            customer_email: `billing+${teamId}@nimbus.dev`,
+            period_start: periodStartUnix,
+            period_end: periodEndUnix,
+            subtotal: seatAmount,
+            tax: 0,
+            total: seatAmount,
+            lines: {
+                object: 'list',
+                data: [
+                    {
+                        id: `il_demo_${generateDemoId(14)}`,
+                        object: 'line_item',
+                        description: `${planDetails.name} (${seats} seat${seats !== 1 ? 's' : ''} x $${(planDetails.amount_cents / 100).toFixed(2)}/mo)`,
+                        amount: seatAmount,
+                        currency: planDetails.currency,
+                        quantity: seats,
+                        period: { start: periodStartUnix, end: periodEndUnix },
+                    },
+                ],
+                total_count: 1,
+            },
+            payment_intent: {
+                id: `pi_demo_${generateDemoId(24)}`,
+                object: 'payment_intent',
+                status: 'succeeded',
+                amount: seatAmount,
+                currency: planDetails.currency,
+            },
+            hosted_invoice_url: `https://invoice.stripe.com/i/demo/${invoiceId}`,
+            invoice_pdf: `https://pay.stripe.com/invoice/${invoiceId}/pdf`,
+            created: createdTimestamp,
+        },
+        metadata: {
+            team_id: teamId,
+            plan_name: planDetails.name,
+            provisioned_by: 'nimbus-billing-service',
+        },
+        default_payment_method: {
+            id: `pm_demo_${generateDemoId(14)}`,
+            object: 'payment_method',
+            type: 'card',
+            card: {
+                brand: 'visa',
+                last4: '4242',
+                exp_month: 12,
+                exp_year: new Date().getFullYear() + 2,
+                funding: 'credit',
+            },
+        },
+    };
+}
+/**
+ * Build quota status relative to the team's plan.
+ * Preserved verbatim from billing-service/src/routes/usage.ts.
+ */
+function buildQuota(plan, totalTokens, totalOperations, totalCost) {
+    const quota = PLAN_QUOTAS[plan] || PLAN_QUOTAS.free;
+    const unlimited = plan === 'enterprise';
+    const tokensLimit = quota.tokensPerMonth;
+    const opsLimit = quota.operationsPerMonth;
+    const costCap = quota.costCapUsd;
+    return {
+        plan,
+        tokens: {
+            used: totalTokens,
+            limit: unlimited ? -1 : tokensLimit,
+            remaining: unlimited ? -1 : Math.max(0, tokensLimit - totalTokens),
+            percentUsed: unlimited
+                ? 0
+                : tokensLimit > 0
+                    ? Math.min(100, Math.round((totalTokens / tokensLimit) * 100 * 100) / 100)
+                    : 0,
+            unlimited,
+        },
+        operations: {
+            used: totalOperations,
+            limit: unlimited ? -1 : opsLimit,
+            remaining: unlimited ? -1 : Math.max(0, opsLimit - totalOperations),
+            percentUsed: unlimited
+                ? 0
+                : opsLimit > 0
+                    ? Math.min(100, Math.round((totalOperations / opsLimit) * 100 * 100) / 100)
+                    : 0,
+            unlimited,
+        },
+        cost: {
+            accrued: Math.round(totalCost * 100) / 100,
+            cap: unlimited ? -1 : costCap,
+            remaining: unlimited ? -1 : Math.max(0, Math.round((costCap - totalCost) * 100) / 100),
+            percentUsed: unlimited
+                ? 0
+                : costCap > 0
+                    ? Math.min(100, Math.round((totalCost / costCap) * 100 * 100) / 100)
+                    : 0,
+            unlimited,
+        },
+    };
+}
+/**
+ * Build rate limit metadata for the current billing window.
+ * Preserved verbatim from billing-service/src/routes/usage.ts.
+ */
+function buildRateLimit(plan) {
+    const limits = {
+        free: { rpm: 30, tpm: 10_000 },
+        pro: { rpm: 120, tpm: 100_000 },
+        enterprise: { rpm: 600, tpm: 1_000_000 },
+    };
+    const planLimits = limits[plan] || limits.free;
+    return {
+        requestsPerMinute: planLimits.rpm,
+        tokensPerMinute: planLimits.tpm,
+        // Simulated current-minute counters (low values for demo)
+        currentMinuteRequests: Math.floor(Math.random() * 5),
+        currentMinuteTokens: Math.floor(Math.random() * 2000),
+    };
+}
+// ---------------------------------------------------------------------------
+// Public API - Subscriptions
+// ---------------------------------------------------------------------------
+/**
+ * Get the current billing status for a team.
+ *
+ * Returns free-plan defaults when no subscription record exists.
+ */
+export async function getBillingStatus(teamId) {
+    const subscription = stateGetSubscription(teamId);
+    if (!subscription) {
+        return {
+            plan: 'free',
+            status: 'active',
+            currentPeriodStart: new Date().toISOString(),
+            currentPeriodEnd: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString(),
+            cancelAtPeriodEnd: false,
+            seats: {
+                used: 1,
+                total: 5,
+            },
+        };
+    }
+    // The unified billing schema (src/state/billing.ts) stores status directly
+    // and does not have cancel_at_period_end or seats_used/seats_total columns.
+    // We derive cancelAtPeriodEnd from status === 'canceled' for backward
+    // compatibility with the original service response shape.
+    return {
+        plan: subscription.plan,
+        status: subscription.status,
+        currentPeriodStart: subscription.currentPeriodStart || new Date().toISOString(),
+        currentPeriodEnd: subscription.currentPeriodEnd ||
+            new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString(),
+        cancelAtPeriodEnd: subscription.status === 'canceled',
+        seats: {
+            used: 1, // seat tracking not available in the unified schema; caller can augment
+            total: PLAN_CATALOG[subscription.plan]?.seats_included ?? 5,
+        },
+    };
+}
+/**
+ * Subscribe a team to a plan.
+ *
+ * Creates or updates the subscription record in the unified database and
+ * returns a rich Stripe-like subscription object for demo presentations.
+ */
+export async function subscribe(request) {
+    const { teamId, plan, seats } = request;
+    if (!teamId) {
+        throw new Error('Team ID is required');
+    }
+    if (!VALID_PLANS.includes(plan)) {
+        throw new Error(`Invalid plan: ${plan}. Must be one of: ${VALID_PLANS.join(', ')}`);
+    }
+    const stripeSubscriptionId = `sub_demo_${generateDemoId(24)}`;
+    const periodStart = new Date();
+    const periodEnd = new Date(Date.now() + 30 * 24 * 60 * 60 * 1000);
+    const seatsTotal = seats || (plan === 'enterprise' ? 100 : plan === 'pro' ? 25 : 5);
+    const stripeCustomerId = `cus_demo_${generateDemoId(14)}`;
+    const existing = stateGetSubscription(teamId);
+    if (existing) {
+        stateUpdateSubscription(teamId, {
+            plan,
+            status: 'active',
+            currentPeriodStart: periodStart.toISOString(),
+            currentPeriodEnd: periodEnd.toISOString(),
+        });
+    }
+    else {
+        stateCreateSubscription(crypto.randomUUID(), teamId, plan, 'active', periodStart.toISOString(), periodEnd.toISOString());
+    }
+    const billingStatus = await getBillingStatus(teamId);
+    const stripeObject = buildStripeSubscription(teamId, plan, stripeSubscriptionId, stripeCustomerId, periodStart, periodEnd, seatsTotal);
+    return {
+        billing: billingStatus,
+        stripe: stripeObject,
+    };
+}
+/**
+ * Cancel a team's active subscription.
+ *
+ * Marks the subscription as canceled in the unified database and returns a
+ * Stripe-like cancellation confirmation object.
+ */
+export async function cancelSubscription(teamId) {
+    if (!teamId) {
+        throw new Error('Team ID is required');
+    }
+    const subscription = stateGetSubscription(teamId);
+    if (!subscription) {
+        throw new Error('No subscription found');
+    }
+    if (subscription.plan === 'free') {
+        throw new Error('Cannot cancel free plan');
+    }
+    const canceledAt = new Date();
+    stateUpdateSubscription(teamId, { status: 'canceled' });
+    const billingStatus = await getBillingStatus(teamId);
+    const periodEnd = subscription.currentPeriodEnd
+        ? new Date(subscription.currentPeriodEnd)
+        : new Date(Date.now() + 30 * 24 * 60 * 60 * 1000);
+    return {
+        billing: billingStatus,
+        cancellation: {
+            id: `sub_demo_${generateDemoId(24)}`,
+            object: 'subscription',
+            status: 'canceled',
+            canceled_at: Math.floor(canceledAt.getTime() / 1000),
+            cancel_at_period_end: true,
+            current_period_end: Math.floor(periodEnd.getTime() / 1000),
+            ended_at: null,
+            cancellation_details: {
+                comment: null,
+                feedback: null,
+                reason: 'cancellation_requested',
+            },
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Public API - Usage tracking
+// ---------------------------------------------------------------------------
+/**
+ * Record a usage event for a team.
+ *
+ * Validates numeric inputs and returns a confirmation receipt with the
+ * generated record ID.
+ */
+export async function recordUsage(request) {
+    const { teamId, userId, operationType, tokensUsed, costUsd } = request;
+    if (!teamId || !operationType) {
+        throw new Error('Team ID and operation type are required');
+    }
+    if (!Number.isFinite(tokensUsed) || tokensUsed < 0) {
+        throw new Error('tokensUsed must be a non-negative number');
+    }
+    if (!Number.isFinite(costUsd) || costUsd < 0) {
+        throw new Error('costUsd must be a non-negative number');
+    }
+    const id = crypto.randomUUID();
+    // stateRecordUsage(id, type, quantity, unit, costUsd, teamId, userId, metadata?)
+    stateRecordUsage(id, operationType, tokensUsed, 'tokens', costUsd, teamId, userId);
+    return {
+        recorded: true,
+        id,
+        timestamp: new Date().toISOString(),
+        teamId,
+        operationType,
+        tokensUsed,
+        costUsd,
+    };
+}
+/**
+ * Get a usage summary for a team over a given period.
+ *
+ * Returns an enhanced summary with daily breakdown, quota status relative to
+ * the team's current plan, and rate limit metadata.
+ */
+export async function getUsage(teamId, period = 'month') {
+    const now = new Date();
+    let since;
+    switch (period) {
+        case 'day':
+            since = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+            break;
+        case 'week':
+            since = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+            break;
+        case 'month':
+        default:
+            since = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
+            break;
+    }
+    // The unified billing state module provides getUsageSummary() aggregated by
+    // type, and getUsage() for raw records. We use getUsageSummary() for
+    // byOperationType totals and getUsage() for per-user and daily breakdowns.
+    const summaryRows = stateGetUsageSummary(teamId, since, now);
+    const rawRecords = stateGetUsage(teamId, since, now, 10000, 0);
+    // Aggregate totals and byOperationType from summary rows
+    let totalOperations = 0;
+    let totalTokens = 0;
+    let totalCost = 0;
+    const byOperationType = {};
+    for (const row of summaryRows) {
+        totalOperations += row.count;
+        totalTokens += row.totalQuantity;
+        totalCost += row.totalCost;
+        byOperationType[row.type] = {
+            count: row.count,
+            tokensUsed: row.totalQuantity,
+            costUsd: row.totalCost,
+        };
+    }
+    // Aggregate byUser from raw records
+    const byUser = {};
+    for (const rec of rawRecords) {
+        if (rec.userId) {
+            const existing = byUser[rec.userId] ?? { count: 0, tokensUsed: 0, costUsd: 0 };
+            byUser[rec.userId] = {
+                count: existing.count + 1,
+                tokensUsed: existing.tokensUsed + rec.quantity,
+                costUsd: existing.costUsd + (rec.costUsd ?? 0),
+            };
+        }
+    }
+    // Build daily breakdown from raw records (group by calendar date)
+    const dailyMap = {};
+    for (const rec of rawRecords) {
+        const date = rec.createdAt.slice(0, 10); // "YYYY-MM-DD"
+        const existing = dailyMap[date] ?? { operations: 0, tokensUsed: 0, costUsd: 0 };
+        dailyMap[date] = {
+            operations: existing.operations + 1,
+            tokensUsed: existing.tokensUsed + rec.quantity,
+            costUsd: existing.costUsd + (rec.costUsd ?? 0),
+        };
+    }
+    const dailyBreakdown = Object.entries(dailyMap)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([date, agg]) => ({ date, ...agg }));
+    // Resolve the team's current plan for quota calculation
+    const subscription = stateGetSubscription(teamId);
+    const plan = subscription?.plan || 'free';
+    return {
+        period: {
+            start: since.toISOString(),
+            end: now.toISOString(),
+        },
+        totals: {
+            operations: totalOperations,
+            tokensUsed: totalTokens,
+            costUsd: Math.round(totalCost * 100) / 100,
+        },
+        byOperationType,
+        byUser: Object.keys(byUser).length > 0 ? byUser : undefined,
+        dailyBreakdown,
+        quota: buildQuota(plan, totalTokens, totalOperations, totalCost),
+        rateLimit: buildRateLimit(plan),
+    };
+}

package/dist/src/enterprise/index.js

@@ -0,0 +1,16 @@
+/**
+ * Enterprise module barrel re-exports.
+ *
+ * Provides a single import point for all embedded enterprise functionality:
+ *   - Auth: device flow and token management (replaces auth-service)
+ *   - Teams: team CRUD and member management (replaces team-service)
+ *   - Billing: subscriptions and usage tracking (replaces billing-service)
+ *   - Audit: audit logging and export (replaces audit-service)
+ *
+ * Usage:
+ *   import { initiateDeviceFlow, createTeam, subscribe, createLog } from '../enterprise';
+ */
+export * from './auth';
+export * from './teams';
+export * from './billing';
+export * from './audit';