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

package/dist/templates/app/api/devtools/tests/[...path]/route.ts

@@ -1,130 +0,0 @@
-import { auth } from "@nextsparkjs/core/lib/auth";
-import { NextResponse } from "next/server";
-import { readFile, stat } from "fs/promises";
-import { join } from "path";
-import matter from "gray-matter";
-
-/**
- * GET /api/devtools/tests/[...path]
- *
- * Returns content of a specific test documentation file
- * Only accessible to developer role
- *
- * @param path - Array of path segments (e.g., ['auth', 'login.md'])
- */
-export async function GET(
-  request: Request,
-  { params }: { params: Promise<{ path: string[] }> }
-) {
-  try {
-    // Verify developer role
-    const session = await auth.api.getSession({ headers: request.headers });
-
-    if (!session?.user || session.user.role !== "developer") {
-      return NextResponse.json(
-        {
-          success: false,
-          error: "Developer access required",
-        },
-        { status: 403 }
-      );
-    }
-
-    // Await params in Next.js 15
-    const resolvedParams = await params;
-    const pathSegments = resolvedParams.path;
-
-    if (!pathSegments || pathSegments.length === 0) {
-      return NextResponse.json(
-        {
-          success: false,
-          error: "Path is required",
-        },
-        { status: 400 }
-      );
-    }
-
-    // Security: Prevent path traversal attacks
-    const hasTraversal = pathSegments.some(
-      (segment) => segment.includes("..") || segment.includes("/")
-    );
-    if (hasTraversal) {
-      return NextResponse.json(
-        {
-          success: false,
-          error: "Invalid path",
-        },
-        { status: 400 }
-      );
-    }
-
-    // Get active theme from environment
-    const activeTheme = process.env.NEXT_PUBLIC_ACTIVE_THEME || "default";
-
-    // Build file path
-    const filePath = join(
-      process.cwd(),
-      "contents",
-      "themes",
-      activeTheme,
-      "tests",
-      "cypress",
-      "e2e",
-      ...pathSegments
-    );
-
-    // Verify file exists and is a file
-    try {
-      const stats = await stat(filePath);
-      if (!stats.isFile()) {
-        return NextResponse.json(
-          {
-            success: false,
-            error: "Path is not a file",
-          },
-          { status: 400 }
-        );
-      }
-    } catch {
-      return NextResponse.json(
-        {
-          success: false,
-          error: "File not found",
-        },
-        { status: 404 }
-      );
-    }
-
-    // Read file content
-    const fileContent = await readFile(filePath, "utf-8");
-
-    // Parse frontmatter if exists
-    const { data: frontmatter, content } = matter(fileContent);
-
-    return NextResponse.json(
-      {
-        success: true,
-        data: {
-          path: pathSegments.join("/"),
-          content,
-          frontmatter: Object.keys(frontmatter).length > 0 ? frontmatter : undefined,
-          theme: activeTheme,
-        },
-      },
-      { status: 200 }
-    );
-  } catch (error) {
-    console.error("[API] /api/devtools/tests/[...path] error:", error);
-    return NextResponse.json(
-      {
-        success: false,
-        error: process.env.NODE_ENV === "production"
-          ? "Failed to load test file"
-          : error instanceof Error
-            ? error.message
-            : "Unknown error",
-      },
-      { status: 500 }
-    );
-  }
-}

package/dist/templates/app/api/devtools/tests/route.ts

@@ -1,134 +0,0 @@
-import { auth } from "@nextsparkjs/core/lib/auth";
-import { NextResponse } from "next/server";
-import { readdir, stat } from "fs/promises";
-import { join } from "path";
-
-/**
- * File tree node structure
- */
-interface FileTreeNode {
-  name: string;
-  path: string;
-  type: "file" | "folder";
-  children?: FileTreeNode[];
-}
-
-/**
- * Recursively build file tree structure
- */
-async function buildFileTree(dirPath: string, basePath: string): Promise<FileTreeNode[]> {
-  const entries = await readdir(dirPath, { withFileTypes: true });
-  const tree: FileTreeNode[] = [];
-
-  for (const entry of entries) {
-    const fullPath = join(dirPath, entry.name);
-    const relativePath = fullPath.replace(basePath + "/", "");
-
-    if (entry.isDirectory()) {
-      // Recursively process subdirectories
-      const children = await buildFileTree(fullPath, basePath);
-      tree.push({
-        name: entry.name,
-        path: relativePath,
-        type: "folder",
-        children,
-      });
-    } else if (entry.isFile() && entry.name.endsWith(".md")) {
-      // Only include .md files
-      tree.push({
-        name: entry.name,
-        path: relativePath,
-        type: "file",
-      });
-    }
-  }
-
-  // Sort: folders first, then files, both alphabetically
-  return tree.sort((a, b) => {
-    if (a.type === b.type) {
-      return a.name.localeCompare(b.name);
-    }
-    return a.type === "folder" ? -1 : 1;
-  });
-}
-
-/**
- * GET /api/devtools/tests
- *
- * Returns file tree structure of test documentation files
- * Only accessible to developer role
- */
-export async function GET(request: Request) {
-  try {
-    // Verify developer role
-    const session = await auth.api.getSession({ headers: request.headers });
-
-    if (!session?.user || session.user.role !== "developer") {
-      return NextResponse.json(
-        {
-          success: false,
-          error: "Developer access required",
-        },
-        { status: 403 }
-      );
-    }
-
-    // Get active theme from environment
-    const activeTheme = process.env.NEXT_PUBLIC_ACTIVE_THEME || "default";
-
-    // Build path to test files
-    const testsBasePath = join(
-      process.cwd(),
-      "contents",
-      "themes",
-      activeTheme,
-      "tests",
-      "cypress",
-      "e2e"
-    );
-
-    // Check if directory exists
-    try {
-      await stat(testsBasePath);
-    } catch {
-      return NextResponse.json(
-        {
-          success: true,
-          data: {
-            tree: [],
-            message: "No test files found",
-          },
-        },
-        { status: 200 }
-      );
-    }
-
-    // Build file tree
-    const tree = await buildFileTree(testsBasePath, testsBasePath);
-
-    return NextResponse.json(
-      {
-        success: true,
-        data: {
-          tree,
-          basePath: testsBasePath,
-          theme: activeTheme,
-        },
-      },
-      { status: 200 }
-    );
-  } catch (error) {
-    console.error("[API] /api/devtools/tests error:", error);
-    return NextResponse.json(
-      {
-        success: false,
-        error: process.env.NODE_ENV === "production"
-          ? "Failed to load test files"
-          : error instanceof Error
-            ? error.message
-            : "Unknown error",
-      },
-      { status: 500 }
-    );
-  }
-}

package/dist/templates/app/api/health/route.ts

@@ -1,29 +0,0 @@
-import { queryWithRLS } from "@nextsparkjs/core/lib/db";
-
-export async function GET() {
-  try {
-    // Test database connection
-    await queryWithRLS('SELECT 1');
-    
-    return Response.json({ 
-      status: 'healthy',
-      timestamp: new Date().toISOString(),
-      services: {
-        database: 'connected',
-        api: 'operational'
-      }
-    });
-  } catch (error) {
-    console.error('Health check failed:', error);
-    return Response.json({ 
-      status: 'unhealthy',
-      timestamp: new Date().toISOString(),
-      error: 'Database connection failed',
-      services: {
-        database: 'disconnected',
-        api: 'operational'
-      }
-    }, { status: 503 });
-  }
-}
-

package/dist/templates/app/api/internal/user-metadata/route.ts

@@ -1,36 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server'
-import { MetaService } from '@nextsparkjs/core/lib/services/meta.service'
-
-// Endpoint interno para crear metadata default después del signup
-export async function POST(req: NextRequest) {
-  try {
-    const body = await req.json()
-    const { userId, metadata } = body
-
-    if (!userId) {
-      return NextResponse.json({ error: 'User ID is required' }, { status: 400 })
-    }
-
-    if (!metadata || typeof metadata !== 'object') {
-      return NextResponse.json({ error: 'Metadata is required' }, { status: 400 })
-    }
-
-    // Crear cada grupo de metadata por separado
-    for (const [metaKey, metaValue] of Object.entries(metadata)) {
-      if (metaValue && typeof metaValue === 'object') {
-        await MetaService.setEntityMeta('user', userId, metaKey, metaValue, userId)
-      }
-    }
-
-    return NextResponse.json({ 
-      success: true,
-      message: 'Default metadata created successfully' 
-    })
-  } catch (error) {
-    // Log error for debugging but don't expose details to client
-    console.error('Error creating user metadata:', error)
-    return NextResponse.json({
-      error: 'Internal server error'
-    }, { status: 500 })
-  }
-}

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 }
-    );
-  }
-}