@nextsparkjs/theme-blog 0.1.0-beta.1

package/README.md

@@ -0,0 +1,65 @@
+# Blog Theme
+
+## Activación
+
+Para usar este theme, configura en `.env`:
+
+```bash
+NEXT_PUBLIC_ACTIVE_THEME=blog
+```
+
+Luego regenera el registry y reinicia el servidor:
+
+```bash
+npx tsx scripts/build-registry.mjs --build
+pnpm dev
+```
+
+## Funcionalidades
+
+### Export/Import JSON
+
+El theme incluye funcionalidad de exportación e importación de posts en formato JSON:
+
+- **Export**: Botón en la lista de posts que descarga todos los posts como `posts-{fecha}.json`
+- **Import**: Dialog que permite cargar un archivo JSON con posts
+
+### Permisos
+
+Los permisos están configurados en `permissions.config.ts`:
+
+| Feature | Descripción | Roles |
+|---------|-------------|-------|
+| `posts.export_json` | Exportar posts a JSON | owner |
+| `posts.import_json` | Importar posts desde JSON | owner |
+
+### Componentes
+
+```
+components/
+├── ExportPostsButton.tsx    # Botón de exportación
+├── ImportPostsDialog.tsx    # Modal de importación
+├── PostsToolbar.tsx         # Toolbar con ambos botones
+└── index.ts                 # Exports
+```
+
+### Templates Override
+
+```
+templates/
+└── app/dashboard/(main)/posts/
+    └── page.tsx             # Lista de posts con toolbar
+```
+
+## Usuario de Prueba
+
+| Email | Password | Rol |
+|-------|----------|-----|
+| blogger@nextspark.dev | Testing1234 | owner |
+
+## Modo
+
+- **Teams Mode**: `single-user`
+- Sin colaboración
+- Sin team switcher
+

package/about.md

@@ -0,0 +1,93 @@
+# Blog Theme
+
+## Objetivo
+
+Demostrar el modo `single-user` donde un único usuario tiene control total de su contenido sin colaboración ni equipos de trabajo.
+
+## Producto
+
+**BlogSpace** - Plataforma de blogging personal para creadores de contenido independientes.
+
+## Empresa
+
+**ContentFirst Inc.** - Startup enfocada en herramientas para creadores individuales que valoran la simplicidad y el control total sobre su contenido.
+
+## Teams Mode
+
+```
+single-user
+```
+
+- Personal team automático al registrarse
+- Sin invitaciones
+- Sin team switcher
+- Sin creación de equipos adicionales
+
+## Entidades
+
+| Entidad | Descripción |
+|---------|-------------|
+| posts | Artículos del blog con título, contenido, slug, imagen destacada, estado y categorías |
+
+## Features
+
+| Feature | Descripción | Roles |
+|---------|-------------|-------|
+| posts.export_json | Exportar posts en formato JSON | owner |
+| posts.import_json | Importar posts desde JSON | owner |
+
+## Permisos
+
+| Entidad | create | read | update | delete |
+|---------|:------:|:----:|:------:|:------:|
+| posts | ✅ | ✅ | ✅ | ✅ |
+
+## Usuario de Prueba
+
+| Email | Password | Rol |
+|-------|----------|-----|
+| blog_owner_alex@nextspark.dev | Test1234 | owner |
+
+## Billing
+
+### Modelo de Pricing: Suscripción Simple
+
+> **Los planes y facturas siempre están asociados al team (que en single-user = 1 usuario).**
+
+### Planes Disponibles
+
+| Plan | Mensual | Anual | Descuento |
+|------|---------|-------|-----------|
+| Free | $0 | $0 | - |
+| Creator | $9/mes | $86/año | ~20% off |
+| Pro | $19/mes | $182/año | ~20% off |
+
+### Características por Plan
+
+| Feature | Free | Creator | Pro |
+|---------|:----:|:-------:|:---:|
+| Posts | 3 | Ilimitados | Ilimitados |
+| Dominio custom | ❌ | ✅ | ✅ |
+| Analytics | ❌ | Básicas | Avanzadas |
+| SEO tools | ❌ | ❌ | ✅ |
+| Branding plataforma | ✅ | ✅ | ❌ |
+| Export JSON | ❌ | ✅ | ✅ |
+| Import JSON | ❌ | ❌ | ✅ |
+
+### Facturación
+
+- **Unidad de cobro:** Por team (1 team = 1 usuario)
+- **Ciclos:** Mensual o anual (20% descuento)
+
+### Sample Invoices
+
+| Team | Plan | Invoices | Status | Total |
+|------|------|----------|--------|-------|
+| Alex's Blog | Creator | 6 | 5 paid + 1 pending | $54 |
+
+## Casos de Uso
+
+1. Blogger independiente que publica artículos
+2. Portafolio personal con blog integrado
+3. Newsletter con archivo de contenido
+

package/api/authors/[username]/route.ts

@@ -0,0 +1,150 @@
+/**
+ * Author Profile API Endpoint (Blog Theme)
+ *
+ * Returns public author profile with published posts.
+ * NO authentication required.
+ *
+ * URL: /api/v1/theme/blog/authors/{username}
+ */
+
+import { NextRequest, NextResponse } from 'next/server'
+import { queryWithRLS } from '@nextsparkjs/core/lib/db'
+
+interface Author {
+  id: string
+  name: string | null
+  username: string | null
+  bio: string | null
+  image: string | null
+  socialTwitter: string | null
+  socialLinkedin: string | null
+  socialWebsite: string | null
+}
+
+interface Post {
+  id: string
+  title: string
+  slug: string
+  excerpt: string | null
+  featuredImage: string | null
+  status: string
+  publishedAt: string | null
+  featured: boolean
+  createdAt: string
+}
+
+interface RouteContext {
+  params: Promise<{
+    username: string
+  }>
+}
+
+export async function GET(
+  request: NextRequest,
+  context: RouteContext
+) {
+  try {
+    const { username } = await context.params
+
+    if (!username) {
+      return NextResponse.json(
+        { success: false, error: 'Username is required' },
+        { status: 400 }
+      )
+    }
+
+    // Get author profile
+    const authorQuery = `
+      SELECT
+        id,
+        name,
+        username,
+        bio,
+        image,
+        "social_twitter" as "socialTwitter",
+        "social_linkedin" as "socialLinkedin",
+        "social_website" as "socialWebsite"
+      FROM users
+      WHERE username = $1
+    `
+
+    const authors = await queryWithRLS<Author>(authorQuery, [username])
+
+    if (authors.length === 0) {
+      return NextResponse.json(
+        { success: false, error: 'Author not found' },
+        { status: 404 }
+      )
+    }
+
+    const author = authors[0]
+
+    // Get author's published posts
+    const postsQuery = `
+      SELECT
+        id,
+        title,
+        slug,
+        excerpt,
+        "featuredImage",
+        status,
+        "publishedAt",
+        featured,
+        "createdAt"
+      FROM posts
+      WHERE "userId" = $1
+        AND status = 'published'
+        AND "publishedAt" <= NOW()
+      ORDER BY "publishedAt" DESC
+      LIMIT 50
+    `
+
+    const posts = await queryWithRLS<Post>(postsQuery, [author.id])
+
+    // Get post count
+    const countQuery = `
+      SELECT COUNT(*) as total
+      FROM posts
+      WHERE "userId" = $1
+        AND status = 'published'
+        AND "publishedAt" <= NOW()
+    `
+
+    const countResult = await queryWithRLS<{ total: string }>(countQuery, [author.id])
+    const totalPosts = parseInt(countResult[0]?.total || '0')
+
+    // Return author profile with posts and stats
+    return NextResponse.json({
+      success: true,
+      data: {
+        author: {
+          id: author.id,
+          name: author.name,
+          username: author.username,
+          bio: author.bio,
+          image: author.image,
+          socialTwitter: author.socialTwitter,
+          socialLinkedin: author.socialLinkedin,
+          socialWebsite: author.socialWebsite
+        },
+        posts,
+        stats: {
+          totalPosts
+        }
+      }
+    })
+
+  } catch (error) {
+    console.error(`[API] /api/v1/theme/blog/authors/[username] - Error:`, error)
+
+    return NextResponse.json(
+      {
+        success: false,
+        error: process.env.NODE_ENV === 'production'
+          ? 'An error occurred while fetching author profile'
+          : (error as Error).message
+      },
+      { status: 500 }
+    )
+  }
+}

package/api/authors/route.ts

@@ -0,0 +1,63 @@
+/**
+ * Authors List API Endpoint (Blog Theme)
+ *
+ * Returns list of all authors with published posts.
+ * NO authentication required.
+ *
+ * URL: /api/v1/theme/blog/authors
+ */
+
+import { NextRequest, NextResponse } from 'next/server'
+import { queryWithRLS } from '@nextsparkjs/core/lib/db'
+
+interface AuthorWithCount {
+  id: string
+  name: string | null
+  username: string | null
+  bio: string | null
+  image: string | null
+  postCount: number
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    // Get all authors who have at least one published post
+    const authorsQuery = `
+      SELECT
+        u.id,
+        u.name,
+        u.username,
+        u.bio,
+        u.image,
+        COUNT(p.id)::integer as "postCount"
+      FROM users u
+      INNER JOIN posts p ON p."userId" = u.id
+      WHERE u.username IS NOT NULL
+        AND p.status = 'published'
+        AND p."publishedAt" <= NOW()
+      GROUP BY u.id, u.name, u.username, u.bio, u.image
+      HAVING COUNT(p.id) > 0
+      ORDER BY COUNT(p.id) DESC, u.name ASC
+    `
+
+    const authors = await queryWithRLS<AuthorWithCount>(authorsQuery, [])
+
+    return NextResponse.json({
+      success: true,
+      data: authors
+    })
+
+  } catch (error) {
+    console.error(`[API] /api/v1/theme/blog/authors - Error:`, error)
+
+    return NextResponse.json(
+      {
+        success: false,
+        error: process.env.NODE_ENV === 'production'
+          ? 'An error occurred while fetching authors'
+          : (error as Error).message
+      },
+      { status: 500 }
+    )
+  }
+}

package/api/posts/public/route.ts

@@ -0,0 +1,151 @@
+/**
+ * Public Posts API Endpoint (Blog Theme)
+ *
+ * Returns published posts from ALL authors for the public feed.
+ * NO authentication required.
+ * NO team_id filtering - shows posts cross-team.
+ *
+ * URL: /api/v1/theme/blog/posts/public
+ */
+
+import { NextRequest, NextResponse } from 'next/server'
+import { queryWithRLS } from '@nextsparkjs/core/lib/db'
+
+interface Post {
+  id: string
+  title: string
+  slug: string
+  excerpt: string | null
+  content: string
+  featuredImage: string | null
+  status: string
+  publishedAt: string | null
+  featured: boolean
+  createdAt: string
+  updatedAt: string
+  userId: string
+  teamId: string
+  // Author data
+  authorName: string | null
+  authorUsername: string | null
+  authorImage: string | null
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url)
+
+    // Pagination parameters
+    const limit = Math.min(parseInt(searchParams.get('limit') || '10'), 100) // Max 100
+    const offset = parseInt(searchParams.get('offset') || '0')
+
+    // Filter parameters
+    const category = searchParams.get('category') // Optional category filter
+
+    // Build query
+    let query = `
+      SELECT
+        p.id,
+        p.title,
+        p.slug,
+        p.excerpt,
+        p.content,
+        p."featuredImage",
+        p.status,
+        p."publishedAt",
+        p.featured,
+        p."createdAt",
+        p."updatedAt",
+        p."userId",
+        p."teamId",
+        u.name as "authorName",
+        u.username as "authorUsername",
+        u.image as "authorImage"
+      FROM posts p
+      INNER JOIN users u ON p."userId" = u.id
+      WHERE p.status = 'published'
+        AND p."publishedAt" <= NOW()
+    `
+
+    const params: unknown[] = []
+    let paramCount = 0
+
+    // Add category filter if provided
+    if (category) {
+      paramCount++
+      query += `
+        AND EXISTS (
+          SELECT 1 FROM post_categories pc
+          INNER JOIN categories c ON pc."categoryId" = c.id
+          WHERE pc."postId" = p.id
+          AND c.slug = $${paramCount}
+        )
+      `
+      params.push(category)
+    }
+
+    // Order by published date (newest first)
+    query += ` ORDER BY p."publishedAt" DESC`
+
+    // Add pagination
+    paramCount++
+    query += ` LIMIT $${paramCount}`
+    params.push(limit)
+
+    paramCount++
+    query += ` OFFSET $${paramCount}`
+    params.push(offset)
+
+    // Execute query WITHOUT RLS context (public access)
+    const posts = await queryWithRLS<Post>(query, params)
+
+    // Get total count for pagination metadata
+    let countQuery = `
+      SELECT COUNT(*) as total
+      FROM posts p
+      WHERE p.status = 'published'
+        AND p."publishedAt" <= NOW()
+    `
+
+    const countParams: unknown[] = []
+    if (category) {
+      countQuery += `
+        AND EXISTS (
+          SELECT 1 FROM post_categories pc
+          INNER JOIN categories c ON pc."categoryId" = c.id
+          WHERE pc."postId" = p.id
+          AND c.slug = $1
+        )
+      `
+      countParams.push(category)
+    }
+
+    const countResult = await queryWithRLS<{ total: string }>(countQuery, countParams)
+    const total = parseInt(countResult[0]?.total || '0')
+
+    // Return response with pagination metadata
+    return NextResponse.json({
+      success: true,
+      data: posts,
+      pagination: {
+        total,
+        limit,
+        offset,
+        hasMore: offset + posts.length < total
+      }
+    })
+
+  } catch (error) {
+    console.error('[API] /api/v1/theme/blog/posts/public - Error:', error)
+
+    return NextResponse.json(
+      {
+        success: false,
+        error: process.env.NODE_ENV === 'production'
+          ? 'An error occurred while fetching posts'
+          : (error as Error).message
+      },
+      { status: 500 }
+    )
+  }
+}

package/components/ExportPostsButton.tsx

@@ -0,0 +1,102 @@
+'use client'
+
+import { useState } from 'react'
+import { Button } from '@nextsparkjs/core/components/ui/button'
+import { Download, Loader2 } from 'lucide-react'
+import { useToast } from '@nextsparkjs/core/hooks/useToast'
+
+interface ExportPostsButtonProps {
+  className?: string
+}
+
+export function ExportPostsButton({ className }: ExportPostsButtonProps) {
+  const [isExporting, setIsExporting] = useState(false)
+  const { toast } = useToast()
+
+  const handleExport = async () => {
+    setIsExporting(true)
+    
+    try {
+      const response = await fetch('/api/v1/posts?limit=1000', {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      })
+
+      if (!response.ok) {
+        throw new Error('Failed to fetch posts')
+      }
+
+      const data = await response.json()
+      const posts = data.data || []
+
+      if (posts.length === 0) {
+        toast({
+          title: 'No posts to export',
+          description: 'Create some posts first before exporting.',
+          variant: 'default',
+        })
+        return
+      }
+
+      // Prepare export data (remove internal fields)
+      const exportData = posts.map((post: Record<string, unknown>) => ({
+        title: post.title,
+        slug: post.slug,
+        content: post.content,
+        excerpt: post.excerpt,
+        featuredImage: post.featuredImage,
+        status: post.status,
+        publishedAt: post.publishedAt,
+        category: post.category,
+        tags: post.tags,
+      }))
+
+      // Create and download file
+      const blob = new Blob([JSON.stringify(exportData, null, 2)], {
+        type: 'application/json',
+      })
+      const url = URL.createObjectURL(blob)
+      const link = document.createElement('a')
+      link.href = url
+      link.download = `posts-${new Date().toISOString().split('T')[0]}.json`
+      document.body.appendChild(link)
+      link.click()
+      document.body.removeChild(link)
+      URL.revokeObjectURL(url)
+
+      toast({
+        title: 'Export successful',
+        description: `${posts.length} posts exported to JSON.`,
+      })
+    } catch (error) {
+      console.error('Export error:', error)
+      toast({
+        title: 'Export failed',
+        description: 'Could not export posts. Please try again.',
+        variant: 'destructive',
+      })
+    } finally {
+      setIsExporting(false)
+    }
+  }
+
+  return (
+    <Button
+      variant="outline"
+      size="sm"
+      onClick={handleExport}
+      disabled={isExporting}
+      className={className}
+    >
+      {isExporting ? (
+        <Loader2 className="h-4 w-4 mr-2 animate-spin" />
+      ) : (
+        <Download className="h-4 w-4 mr-2" />
+      )}
+      Export JSON
+    </Button>
+  )
+}
+