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

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

@@ -1,310 +0,0 @@
-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/dist/templates/app/api/superadmin/teams/[teamId]/route.ts

@@ -1,286 +0,0 @@
-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 }
-    );
-  }
-}