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

package/templates/app/api/devtools/config/entities/route.ts

@@ -0,0 +1,108 @@
+import { auth } from "@nextsparkjs/core/lib/auth";
+import { NextResponse } from "next/server";
+import { ENTITY_REGISTRY } from "@nextsparkjs/registries/entity-registry";
+
+/**
+ * Entity information structure
+ */
+interface EntityInfo {
+  slug: string;
+  name: string;
+  pluralName: string;
+  icon: string;
+  enabled: boolean;
+  access: {
+    public: boolean;
+    api: boolean;
+    metadata: boolean;
+    shared: boolean;
+  };
+  fields: {
+    name: string;
+    type: string;
+    label?: string;
+    required?: boolean;
+  }[];
+  // Permissions are now optional in entity config (centralized in permissions.config.ts)
+  permissions?: {
+    actions: Array<{ action: string; label: string; description?: string }>;
+    customActions?: Array<{ action: string; label: string; description?: string }>;
+  };
+}
+
+/**
+ * GET /api/devtools/config/entities
+ *
+ * Returns entity registry information
+ * 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 }
+      );
+    }
+
+    // Build entity info array
+    const entities: EntityInfo[] = [];
+
+    for (const [, entry] of Object.entries(ENTITY_REGISTRY)) {
+      const config = entry.config;
+
+      entities.push({
+        slug: config.slug,
+        name: config.names.singular,
+        pluralName: config.names.plural,
+        icon: config.icon?.name || 'Circle',
+        enabled: config.enabled,
+        access: config.access,
+        fields: config.fields?.map((field: {
+          name: string;
+          type: string;
+          label?: string;
+          required?: boolean;
+        }) => ({
+          name: field.name,
+          type: field.type,
+          label: field.label,
+          required: field.required,
+        })) || [],
+      });
+    }
+
+    // Sort entities alphabetically
+    entities.sort((a, b) => a.slug.localeCompare(b.slug));
+
+    return NextResponse.json(
+      {
+        success: true,
+        data: {
+          entities,
+          count: entities.length,
+        },
+      },
+      { status: 200 }
+    );
+  } catch (error) {
+    console.error("[API] /api/devtools/config/entities error:", error);
+    return NextResponse.json(
+      {
+        success: false,
+        error: process.env.NODE_ENV === "production"
+          ? "Failed to load entity configuration"
+          : error instanceof Error
+            ? error.message
+            : "Unknown error",
+      },
+      { status: 500 }
+    );
+  }
+}

package/templates/app/api/devtools/config/theme/route.ts

@@ -0,0 +1,66 @@
+import { auth } from "@nextsparkjs/core/lib/auth";
+import { NextResponse } from "next/server";
+import { ThemeService } from "@nextsparkjs/core/lib/services/theme.service";
+
+/**
+ * GET /api/devtools/config/theme
+ *
+ * Returns current theme configuration
+ * 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";
+
+    // Get theme configuration from registry
+    const themeConfig = ThemeService.getAppConfig(activeTheme);
+
+    if (!themeConfig) {
+      return NextResponse.json(
+        {
+          success: false,
+          error: `Theme configuration not found for theme: ${activeTheme}`,
+        },
+        { status: 404 }
+      );
+    }
+
+    return NextResponse.json(
+      {
+        success: true,
+        data: {
+          theme: activeTheme,
+          config: themeConfig,
+        },
+      },
+      { status: 200 }
+    );
+  } catch (error) {
+    console.error("[API] /api/devtools/config/theme error:", error);
+    return NextResponse.json(
+      {
+        success: false,
+        error: process.env.NODE_ENV === "production"
+          ? "Failed to load theme configuration"
+          : error instanceof Error
+            ? error.message
+            : "Unknown error",
+      },
+      { status: 500 }
+    );
+  }
+}

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

@@ -0,0 +1,130 @@
+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/templates/app/api/devtools/tests/route.ts

@@ -0,0 +1,134 @@
+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/templates/app/api/health/route.ts

@@ -0,0 +1,29 @@
+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/templates/app/api/internal/user-metadata/route.ts

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