@nextsparkjs/core 0.1.0-beta.83 → 0.1.0-beta.85

package/templates/app/api/superadmin/subscriptions/route.ts

@@ -0,0 +1,310 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@nextsparkjs/core/lib/auth';
+import { queryWithRLS } from '@nextsparkjs/core/lib/db';
+
+interface SubscriptionResult {
+  id: string;
+  teamId: string;
+  teamName: string;
+  ownerName: string;
+  ownerEmail: string;
+  planId: string;
+  planSlug: string;
+  planName: string;
+  planType: string;
+  status: string;
+  priceMonthly: number | null;
+  priceYearly: number | null;
+  billingInterval: 'monthly' | 'yearly';
+  currentPeriodStart: string;
+  currentPeriodEnd: string;
+  trialEndsAt: string | null;
+  canceledAt: string | null;
+  cancelAtPeriodEnd: boolean;
+  externalSubscriptionId: string | null;
+  createdAt: string;
+}
+
+interface StatsResult {
+  totalSubscriptions: string;
+  activeSubscriptions: string;
+  trialingSubscriptions: string;
+  canceledSubscriptions: string;
+  pastDueSubscriptions: string;
+  freeSubscriptions: string;
+  paidSubscriptions: string;
+  monthlySubscriptions: string;
+  yearlySubscriptions: string;
+  totalMRR: string;
+  totalARR: string;
+}
+
+interface PlanDistribution {
+  planSlug: string;
+  planName: string;
+  count: string;
+}
+
+/**
+ * GET /api/superadmin/subscriptions
+ *
+ * Retrieves all subscriptions with stats for superadmin overview.
+ * Supports filtering by status and pagination.
+ */
+export async function GET(request: NextRequest) {
+  try {
+    // Get the current session using Better Auth
+    const session = await auth.api.getSession({
+      headers: request.headers
+    });
+
+    // Check if user is authenticated
+    if (!session?.user) {
+      return NextResponse.json(
+        { error: 'Unauthorized - No session found' },
+        { status: 401 }
+      );
+    }
+
+    // Check if user is superadmin or developer
+    if (session.user.role !== 'superadmin' && session.user.role !== 'developer') {
+      return NextResponse.json(
+        { error: 'Forbidden - Superadmin or developer access required' },
+        { status: 403 }
+      );
+    }
+
+    // Parse query params
+    const searchParams = request.nextUrl.searchParams;
+    const status = searchParams.get('status');
+    const plan = searchParams.get('plan');
+    const interval = searchParams.get('interval');
+    const search = searchParams.get('search');
+    const page = parseInt(searchParams.get('page') || '1', 10);
+    const limit = parseInt(searchParams.get('limit') || '20', 10);
+    const offset = (page - 1) * limit;
+
+    // Build WHERE clause
+    const conditions: string[] = [];
+    const queryParams: unknown[] = [];
+    let paramIndex = 1;
+
+    if (status && status !== 'all') {
+      conditions.push(`s.status = $${paramIndex}`);
+      queryParams.push(status);
+      paramIndex++;
+    }
+
+    if (plan && plan !== 'all') {
+      conditions.push(`p.slug = $${paramIndex}`);
+      queryParams.push(plan);
+      paramIndex++;
+    }
+
+    if (interval && interval !== 'all') {
+      conditions.push(`s."billingInterval" = $${paramIndex}`);
+      queryParams.push(interval);
+      paramIndex++;
+    }
+
+    if (search) {
+      conditions.push(`(
+        t.name ILIKE $${paramIndex} OR
+        u.email ILIKE $${paramIndex} OR
+        p.name ILIKE $${paramIndex}
+      )`);
+      queryParams.push(`%${search}%`);
+      paramIndex++;
+    }
+
+    const whereClause = conditions.length > 0
+      ? `WHERE ${conditions.join(' AND ')}`
+      : '';
+
+    // Query for stats
+    const statsQuery = `
+      SELECT
+        COUNT(*) as "totalSubscriptions",
+        COUNT(*) FILTER (WHERE s.status = 'active') as "activeSubscriptions",
+        COUNT(*) FILTER (WHERE s.status = 'trialing') as "trialingSubscriptions",
+        COUNT(*) FILTER (WHERE s.status = 'canceled') as "canceledSubscriptions",
+        COUNT(*) FILTER (WHERE s.status = 'past_due') as "pastDueSubscriptions",
+        COUNT(*) FILTER (WHERE p.type = 'free') as "freeSubscriptions",
+        COUNT(*) FILTER (WHERE p.type IN ('paid', 'enterprise')) as "paidSubscriptions",
+        COUNT(*) FILTER (WHERE s."billingInterval" = 'monthly') as "monthlySubscriptions",
+        COUNT(*) FILTER (WHERE s."billingInterval" = 'yearly') as "yearlySubscriptions",
+        COALESCE(SUM(p."priceMonthly") FILTER (
+          WHERE s.status IN ('active', 'trialing')
+          AND s."billingInterval" = 'monthly'
+          AND p."priceMonthly" > 0
+        ), 0) as "totalMRR",
+        COALESCE(SUM(p."priceYearly") FILTER (
+          WHERE s.status IN ('active', 'trialing')
+          AND s."billingInterval" = 'yearly'
+          AND p."priceYearly" > 0
+        ), 0) as "totalARR"
+      FROM "subscriptions" s
+      LEFT JOIN "plans" p ON s."planId" = p.id
+    `;
+
+    // Query for plan distribution
+    const planDistributionQuery = `
+      SELECT
+        p.slug as "planSlug",
+        p.name as "planName",
+        COUNT(*) as count
+      FROM "subscriptions" s
+      LEFT JOIN "plans" p ON s."planId" = p.id
+      WHERE s.status IN ('active', 'trialing')
+      GROUP BY p.slug, p.name
+      ORDER BY count DESC
+    `;
+
+    // Query for subscriptions list
+    const subscriptionsQuery = `
+      SELECT
+        s.id,
+        s."teamId",
+        t.name as "teamName",
+        COALESCE(u."firstName" || ' ' || u."lastName", u.email) as "ownerName",
+        u.email as "ownerEmail",
+        s."planId",
+        p.slug as "planSlug",
+        p.name as "planName",
+        p.type as "planType",
+        s.status,
+        p."priceMonthly",
+        p."priceYearly",
+        s."billingInterval",
+        s."currentPeriodStart",
+        s."currentPeriodEnd",
+        s."trialEndsAt",
+        s."canceledAt",
+        s."cancelAtPeriodEnd",
+        s."externalSubscriptionId",
+        s."createdAt"
+      FROM "subscriptions" s
+      LEFT JOIN "teams" t ON s."teamId" = t.id
+      LEFT JOIN "users" u ON t."ownerId" = u.id
+      LEFT JOIN "plans" p ON s."planId" = p.id
+      ${whereClause}
+      ORDER BY s."createdAt" DESC
+      LIMIT $${paramIndex} OFFSET $${paramIndex + 1}
+    `;
+
+    // Count query for pagination
+    const countQuery = `
+      SELECT COUNT(*) as total
+      FROM "subscriptions" s
+      LEFT JOIN "teams" t ON s."teamId" = t.id
+      LEFT JOIN "users" u ON t."ownerId" = u.id
+      LEFT JOIN "plans" p ON s."planId" = p.id
+      ${whereClause}
+    `;
+
+    // Execute all queries
+    const [statsResult, planDistResult, subscriptionsResult, countResult] = await Promise.all([
+      queryWithRLS(statsQuery, [], session.user.id) as Promise<StatsResult[]>,
+      queryWithRLS(planDistributionQuery, [], session.user.id) as Promise<PlanDistribution[]>,
+      queryWithRLS(subscriptionsQuery, [...queryParams, limit, offset], session.user.id) as Promise<SubscriptionResult[]>,
+      queryWithRLS(countQuery, queryParams, session.user.id) as Promise<{ total: string }[]>
+    ]);
+
+    const stats = statsResult[0] || {
+      totalSubscriptions: '0',
+      activeSubscriptions: '0',
+      trialingSubscriptions: '0',
+      canceledSubscriptions: '0',
+      pastDueSubscriptions: '0',
+      freeSubscriptions: '0',
+      paidSubscriptions: '0',
+      monthlySubscriptions: '0',
+      yearlySubscriptions: '0',
+      totalMRR: '0',
+      totalARR: '0'
+    };
+
+    const total = parseInt(countResult[0]?.total || '0', 10);
+    const totalPages = Math.ceil(total / limit);
+
+    // Format subscriptions
+    const subscriptions = subscriptionsResult.map(sub => ({
+      id: sub.id,
+      team: {
+        id: sub.teamId,
+        name: sub.teamName,
+        owner: {
+          name: sub.ownerName?.trim() || sub.ownerEmail,
+          email: sub.ownerEmail
+        }
+      },
+      plan: {
+        id: sub.planId,
+        slug: sub.planSlug,
+        name: sub.planName,
+        type: sub.planType,
+        priceMonthly: sub.priceMonthly,
+        priceYearly: sub.priceYearly
+      },
+      billingInterval: sub.billingInterval,
+      status: sub.status,
+      currentPeriodStart: sub.currentPeriodStart,
+      currentPeriodEnd: sub.currentPeriodEnd,
+      trialEndsAt: sub.trialEndsAt,
+      canceledAt: sub.canceledAt,
+      cancelAtPeriodEnd: sub.cancelAtPeriodEnd,
+      externalSubscriptionId: sub.externalSubscriptionId,
+      createdAt: sub.createdAt
+    }));
+
+    // Prepare response
+    const responseData = {
+      stats: {
+        total: parseInt(stats.totalSubscriptions, 10),
+        active: parseInt(stats.activeSubscriptions, 10),
+        trialing: parseInt(stats.trialingSubscriptions, 10),
+        canceled: parseInt(stats.canceledSubscriptions, 10),
+        pastDue: parseInt(stats.pastDueSubscriptions, 10),
+        free: parseInt(stats.freeSubscriptions, 10),
+        paid: parseInt(stats.paidSubscriptions, 10),
+        monthly: parseInt(stats.monthlySubscriptions, 10),
+        yearly: parseInt(stats.yearlySubscriptions, 10),
+        mrr: parseInt(stats.totalMRR, 10), // In cents
+        mrrFormatted: `$${(parseInt(stats.totalMRR, 10) / 100).toFixed(2)}`,
+        arr: parseInt(stats.totalARR, 10), // In cents
+        arrFormatted: `$${(parseInt(stats.totalARR, 10) / 100).toFixed(2)}`
+      },
+      planDistribution: planDistResult.map(p => ({
+        slug: p.planSlug,
+        name: p.planName,
+        count: parseInt(p.count, 10)
+      })),
+      subscriptions,
+      pagination: {
+        page,
+        limit,
+        total,
+        totalPages,
+        hasMore: page < totalPages
+      },
+      metadata: {
+        requestedBy: session.user.id,
+        requestedAt: new Date().toISOString(),
+        source: 'superadmin-api'
+      }
+    };
+
+    return NextResponse.json(responseData);
+
+  } catch (error) {
+    console.error('Error fetching subscriptions:', error);
+
+    return NextResponse.json(
+      {
+        error: 'Internal server error',
+        message: 'Failed to retrieve subscriptions data'
+      },
+      { status: 500 }
+    );
+  }
+}

package/templates/app/api/superadmin/teams/[teamId]/route.ts

@@ -0,0 +1,286 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@nextsparkjs/core/lib/auth';
+import { queryWithRLS } from '@nextsparkjs/core/lib/db';
+
+interface TeamResult {
+  id: string;
+  name: string;
+  ownerId: string;
+  ownerName: string;
+  ownerEmail: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+interface TeamMemberResult {
+  id: string;
+  name: string;
+  email: string;
+  role: string;
+  joinedAt: string;
+  userId: string;
+}
+
+interface SubscriptionResult {
+  id: string;
+  planId: string;
+  planSlug: string;
+  planName: string;
+  planType: string;
+  priceMonthly: number | null;
+  status: string;
+  currentPeriodStart: string;
+  currentPeriodEnd: string;
+  trialEndsAt: string | null;
+  canceledAt: string | null;
+  cancelAtPeriodEnd: boolean;
+  externalSubscriptionId: string | null;
+  externalCustomerId: string | null;
+  createdAt: string;
+}
+
+interface BillingEventResult {
+  id: string;
+  type: string;
+  status: string;
+  amount: number;
+  currency: string;
+  invoiceUrl: string | null;
+  receiptUrl: string | null;
+  createdAt: string;
+}
+
+interface UsageResult {
+  limitSlug: string;
+  currentValue: number;
+  periodKey: string;
+}
+
+/**
+ * GET /api/superadmin/teams/[teamId]
+ *
+ * Retrieves a single team with owner info and members.
+ * Only accessible by superadmin or developer users.
+ */
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ teamId: string }> }
+) {
+  try {
+    const { teamId } = await params;
+
+    // Get the current session using Better Auth
+    const session = await auth.api.getSession({
+      headers: request.headers
+    });
+
+    // Check if user is authenticated
+    if (!session?.user) {
+      return NextResponse.json(
+        { error: 'Unauthorized - No session found' },
+        { status: 401 }
+      );
+    }
+
+    // Check if user is superadmin or developer
+    if (session.user.role !== 'superadmin' && session.user.role !== 'developer') {
+      return NextResponse.json(
+        { error: 'Forbidden - Superadmin or developer access required' },
+        { status: 403 }
+      );
+    }
+
+    // Query for team details
+    const teamQuery = `
+      SELECT
+        t.id,
+        t.name,
+        t."ownerId",
+        COALESCE(u."firstName" || ' ' || u."lastName", u.email) as "ownerName",
+        u.email as "ownerEmail",
+        t."createdAt",
+        t."updatedAt"
+      FROM "teams" t
+      LEFT JOIN "users" u ON t."ownerId" = u.id
+      WHERE t.id = $1
+    `;
+
+    // Query for team members
+    const membersQuery = `
+      SELECT
+        tm.id,
+        tm.role,
+        tm."joinedAt",
+        COALESCE(u."firstName" || ' ' || u."lastName", u.email) as name,
+        u.email,
+        u.id as "userId"
+      FROM "team_members" tm
+      LEFT JOIN "users" u ON tm."userId" = u.id
+      WHERE tm."teamId" = $1
+      ORDER BY
+        CASE tm.role
+          WHEN 'owner' THEN 1
+          WHEN 'admin' THEN 2
+          WHEN 'member' THEN 3
+          WHEN 'viewer' THEN 4
+          ELSE 5
+        END,
+        tm."joinedAt" ASC
+    `;
+
+    // Query for subscription
+    const subscriptionQuery = `
+      SELECT
+        s.id,
+        s."planId",
+        p.slug as "planSlug",
+        p.name as "planName",
+        p.type as "planType",
+        p."priceMonthly",
+        s.status,
+        s."currentPeriodStart",
+        s."currentPeriodEnd",
+        s."trialEndsAt",
+        s."canceledAt",
+        s."cancelAtPeriodEnd",
+        s."externalSubscriptionId",
+        s."externalCustomerId",
+        s."createdAt"
+      FROM "subscriptions" s
+      LEFT JOIN "plans" p ON s."planId" = p.id
+      WHERE s."teamId" = $1
+      ORDER BY s."createdAt" DESC
+      LIMIT 1
+    `;
+
+    // Query for billing events
+    const billingEventsQuery = `
+      SELECT
+        be.id,
+        be.type,
+        be.status,
+        be.amount,
+        be.currency,
+        be."invoiceUrl",
+        be."receiptUrl",
+        be."createdAt"
+      FROM "billing_events" be
+      JOIN "subscriptions" s ON be."subscriptionId" = s.id
+      WHERE s."teamId" = $1
+      ORDER BY be."createdAt" DESC
+      LIMIT 10
+    `;
+
+    // Query for usage
+    const usageQuery = `
+      SELECT
+        u."limitSlug",
+        u."currentValue",
+        u."periodKey"
+      FROM "usage" u
+      JOIN "subscriptions" s ON u."subscriptionId" = s.id
+      WHERE s."teamId" = $1
+    `;
+
+    // Execute queries
+    const [teamResult, membersResult, subscriptionResult, billingEventsResult, usageResult] = await Promise.all([
+      queryWithRLS(teamQuery, [teamId], session.user.id) as Promise<TeamResult[]>,
+      queryWithRLS(membersQuery, [teamId], session.user.id) as Promise<TeamMemberResult[]>,
+      queryWithRLS(subscriptionQuery, [teamId], session.user.id) as Promise<SubscriptionResult[]>,
+      queryWithRLS(billingEventsQuery, [teamId], session.user.id) as Promise<BillingEventResult[]>,
+      queryWithRLS(usageQuery, [teamId], session.user.id) as Promise<UsageResult[]>
+    ]);
+
+    if (!teamResult || teamResult.length === 0) {
+      return NextResponse.json(
+        { error: 'Team not found' },
+        { status: 404 }
+      );
+    }
+
+    const team = teamResult[0];
+    const subscription = subscriptionResult[0] || null;
+
+    // Prepare response data
+    const responseData = {
+      team: {
+        id: team.id,
+        name: team.name,
+        owner: {
+          id: team.ownerId,
+          name: team.ownerName?.trim() || team.ownerEmail,
+          email: team.ownerEmail
+        },
+        memberCount: membersResult.length,
+        createdAt: team.createdAt,
+        updatedAt: team.updatedAt
+      },
+      members: membersResult.map((member) => ({
+        id: member.id,
+        userId: member.userId,
+        name: member.name?.trim() || member.email,
+        email: member.email,
+        role: member.role,
+        joinedAt: member.joinedAt
+      })),
+      subscription: subscription ? {
+        id: subscription.id,
+        plan: {
+          id: subscription.planId,
+          slug: subscription.planSlug,
+          name: subscription.planName,
+          type: subscription.planType,
+          priceMonthly: subscription.priceMonthly,
+          priceFormatted: subscription.priceMonthly
+            ? `$${(subscription.priceMonthly / 100).toFixed(2)}/mo`
+            : 'Free'
+        },
+        status: subscription.status,
+        currentPeriodStart: subscription.currentPeriodStart,
+        currentPeriodEnd: subscription.currentPeriodEnd,
+        trialEndsAt: subscription.trialEndsAt,
+        canceledAt: subscription.canceledAt,
+        cancelAtPeriodEnd: subscription.cancelAtPeriodEnd,
+        externalSubscriptionId: subscription.externalSubscriptionId,
+        externalCustomerId: subscription.externalCustomerId,
+        createdAt: subscription.createdAt
+      } : null,
+      billingHistory: billingEventsResult.map((event) => ({
+        id: event.id,
+        type: event.type,
+        status: event.status,
+        amount: event.amount,
+        amountFormatted: `$${(event.amount / 100).toFixed(2)}`,
+        currency: event.currency,
+        invoiceUrl: event.invoiceUrl,
+        receiptUrl: event.receiptUrl,
+        createdAt: event.createdAt
+      })),
+      usage: usageResult.reduce((acc, u) => {
+        acc[u.limitSlug] = {
+          current: u.currentValue,
+          periodKey: u.periodKey
+        };
+        return acc;
+      }, {} as Record<string, { current: number; periodKey: string }>),
+      metadata: {
+        requestedBy: session.user.id,
+        requestedAt: new Date().toISOString(),
+        source: 'superadmin-api'
+      }
+    };
+
+    return NextResponse.json(responseData);
+
+  } catch (error) {
+    console.error('Error fetching team data:', error);
+
+    return NextResponse.json(
+      {
+        error: 'Internal server error',
+        message: 'Failed to retrieve team data'
+      },
+      { status: 500 }
+    );
+  }
+}