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

package/dist/templates/app/(public)/[...slug]/page.tsx

@@ -1,378 +0,0 @@
-/**
- * Public Dynamic Catch-All Route
- *
- * Handles all public URLs for builder-enabled entities based on access.basePath configuration.
- *
- * Resolution strategy (longest-match-first):
- * - /blog/my-post → posts (basePath: '/blog')
- * - /about → pages (basePath: '/')
- * - /blog → posts archive (exact basePath match)
- *
- * Template System:
- * 1. Checks for theme template override first
- * 2. Falls back to default PageRenderer if no template
- */
-
-import { notFound } from 'next/navigation'
-import { query } from '@nextsparkjs/core/lib/db'
-import { PageRenderer } from '@nextsparkjs/core/components/public/pageBuilder'
-import {
-  matchPathToEntity,
-  getEntityBasePath,
-} from '@nextsparkjs/core/lib/entities/schema-generator'
-import { getEntityRegistry, setEntityRegistry } from '@nextsparkjs/core/lib/entities/queries'
-import { TemplateService } from '@nextsparkjs/core/lib/services/template.service'
-import { resolvePublicEntityFromUrl } from '@nextsparkjs/core/lib/api/entity/public-resolver'
-import { PublicEntityGrid } from '@nextsparkjs/core/components/public/entities/PublicEntityGrid'
-import type { EntityConfig } from '@nextsparkjs/core/lib/entities/types'
-import type { Metadata } from 'next'
-// Pattern resolution imports
-import { PatternsResolverService } from '@nextsparkjs/core/lib/blocks/patterns-resolver.service'
-import { extractPatternIds, resolvePatternReferences } from '@nextsparkjs/core/lib/blocks/pattern-resolver'
-import type { BlockInstance } from '@nextsparkjs/core/types/blocks'
-import type { PatternReference } from '@nextsparkjs/core/types/pattern-reference'
-// Import registry directly - webpack resolves @nextsparkjs/registries alias at compile time
-import { ENTITY_REGISTRY, ENTITY_METADATA } from '@nextsparkjs/registries/entity-registry'
-
-// Initialize registry at module load time (before any component renders)
-// This ensures the registry is available even if this page loads before the layout
-setEntityRegistry(ENTITY_REGISTRY, ENTITY_METADATA)
-
-/**
- * Convert entity registry to format expected by matchPathToEntity
- */
-function getEntityConfigs(): Record<string, EntityConfig> {
-  const registry = getEntityRegistry()
-  const configs: Record<string, EntityConfig> = {}
-  for (const [key, entry] of Object.entries(registry)) {
-    configs[key] = entry.config as EntityConfig
-  }
-  return configs
-}
-
-// Enable ISR with 1 hour revalidation
-export const revalidate = 3600
-
-interface PageProps {
-  params: Promise<{ slug: string[] }>
-  searchParams: Promise<{ [key: string]: string | string[] | undefined }>
-}
-
-/**
- * Base fields that all builder-enabled entities have (from migrations)
- * These are the minimum fields needed for public page rendering
- */
-const BASE_PUBLIC_FIELDS = ['id', 'slug', 'title', 'status', 'blocks', 'locale', 'createdAt', 'userId']
-
-/**
- * Optional SEO fields that may exist on builder entities
- */
-const SEO_FIELDS = ['seoTitle', 'seoDescription', 'ogImage']
-
-/**
- * Common optional fields for content entities (posts, articles, etc.)
- * These are checked dynamically - only included if they exist in entity.fields
- */
-const OPTIONAL_CONTENT_FIELDS = ['excerpt', 'featuredImage']
-
-interface PublishedItem {
-  id: string
-  slug: string
-  title: string
-  status: string
-  blocks: Array<{
-    id: string
-    blockSlug: string
-    props: Record<string, unknown>
-  }>
-  excerpt?: string
-  featuredImage?: string
-  seoTitle?: string
-  seoDescription?: string
-  ogImage?: string
-  locale?: string
-  createdAt?: string
-  userId?: string
-}
-
-/**
- * Quote a field name for PostgreSQL (handles camelCase)
- */
-function quoteField(field: string): string {
-  return /[A-Z]/.test(field) ? `"${field}"` : field
-}
-
-/**
- * Build SELECT clause dynamically based on entity configuration
- * Only includes fields that actually exist in the entity's schema
- */
-function buildPublicSelectClause(entity: EntityConfig): string {
-  const fields = new Set<string>(BASE_PUBLIC_FIELDS)
-
-  // Add SEO fields (these are standard for builder entities)
-  SEO_FIELDS.forEach(f => fields.add(f))
-
-  // Check entity.fields for optional content fields
-  const entityFieldNames = entity.fields?.map(f => f.name) || []
-  OPTIONAL_CONTENT_FIELDS.forEach(f => {
-    if (entityFieldNames.includes(f)) {
-      fields.add(f)
-    }
-  })
-
-  return Array.from(fields).map(quoteField).join(', ')
-}
-
-/**
- * Resolve pattern references in blocks array
- *
- * Fetches all referenced patterns and expands them inline.
- * This ensures public pages show the actual pattern content.
- *
- * @param blocks - Blocks array which may contain pattern references
- * @returns Resolved blocks array with patterns expanded
- */
-async function getResolvedBlocks(
-  blocks: (BlockInstance | PatternReference)[]
-): Promise<BlockInstance[]> {
-  // Extract pattern IDs from blocks array
-  const patternIds = extractPatternIds(blocks)
-
-  // If no patterns referenced, return blocks as-is
-  if (patternIds.length === 0) {
-    return blocks as BlockInstance[]
-  }
-
-  try {
-    // Batch fetch all referenced patterns (only published ones)
-    const patterns = await PatternsResolverService.getByIds(patternIds)
-
-    // Build pattern cache (Map for O(1) lookup)
-    const patternCache = new Map(patterns.map((p) => [p.id, p]))
-
-    // Resolve pattern references and return flattened blocks
-    return resolvePatternReferences(blocks, patternCache)
-  } catch (error) {
-    console.error('[getResolvedBlocks] Failed to resolve patterns:', error)
-    // Fallback: Return blocks without pattern resolution
-    // Pattern references will be skipped gracefully
-    return blocks.filter((block) => !('type' in block && block.type === 'pattern')) as BlockInstance[]
-  }
-}
-
-/**
- * Build the template path for an entity based on its basePath
- */
-function buildTemplatePath(entity: EntityConfig): string {
-  const basePath = getEntityBasePath(entity) || '/'
-  if (basePath === '/') {
-    return 'app/(public)/[entity]/page.tsx'
-  }
-  return `app/(public)${basePath}/[slug]/page.tsx`
-}
-
-/**
- * Fetch a published item from the database
- * Dynamically builds SELECT clause based on entity configuration
- * to avoid querying non-existent columns
- */
-async function fetchPublishedItem(
-  entity: EntityConfig,
-  slug: string
-): Promise<PublishedItem | null> {
-  try {
-    const tableName = entity.tableName || entity.slug
-    const selectClause = buildPublicSelectClause(entity)
-
-    const result = await query<PublishedItem>(
-      `SELECT ${selectClause} FROM "${tableName}" WHERE slug = $1 AND status = 'published'`,
-      [slug]
-    )
-    return result.rows[0] || null
-  } catch (error) {
-    console.error(`[fetchPublishedItem] Error fetching ${entity.slug}:`, error)
-    return null
-  }
-}
-
-/**
- * Generate metadata for the page
- */
-export async function generateMetadata({
-  params,
-}: PageProps): Promise<Metadata> {
-  const slugParts = (await params).slug
-  const fullPath = '/' + slugParts.join('/')
-
-  // Get entity configs from registry
-  const registry = getEntityConfigs()
-
-  // Match path to builder entity
-  const match = matchPathToEntity(fullPath, registry)
-
-  if (match) {
-    const { entity, slug, isArchive } = match
-
-    // Archive page metadata
-    if (isArchive) {
-      return {
-        title: `${entity.names.plural} | Boilerplate`,
-        description: `Browse all ${entity.names.plural.toLowerCase()}`,
-      }
-    }
-
-    // Metadata from database
-    const item = await fetchPublishedItem(entity, slug)
-    if (item) {
-      return {
-        title: item.seoTitle || `${item.title} | Boilerplate`,
-        description: item.seoDescription || item.excerpt || undefined,
-        openGraph: {
-          title: item.seoTitle || item.title,
-          description: item.seoDescription || item.excerpt || undefined,
-          images: item.ogImage
-            ? [item.ogImage]
-            : item.featuredImage
-              ? [item.featuredImage]
-              : [],
-          type: 'article',
-        },
-      }
-    }
-  }
-
-  return {
-    title: 'Not Found',
-  }
-}
-
-/**
- * Main catch-all page component
- */
-export default async function DynamicPublicPage({
-  params,
-  searchParams,
-}: PageProps) {
-  const slugParts = (await params).slug
-  const resolvedSearchParams = await searchParams
-  const fullPath = '/' + slugParts.join('/')
-
-  // Get entity configs from registry
-  const registry = getEntityConfigs()
-
-  // Match path to builder entity using longest-match strategy
-  const match = matchPathToEntity(fullPath, registry)
-
-  if (match) {
-    const { entity, slug, isArchive } = match
-
-    // === ARCHIVE PAGE ===
-    // Handle archive pages (e.g., /blog without slug)
-    if (isArchive) {
-      // Check if entity has archive page configured
-      if (!entity.ui?.public?.hasArchivePage) {
-        notFound()
-      }
-
-      // Check for custom archive template (future enhancement)
-      // For now, use PublicEntityGrid
-      return (
-        <div className="container mx-auto px-4 py-8" data-cy="public-archive-page">
-          <div className="mb-8">
-            <h1 className="text-4xl font-bold text-foreground mb-4">
-              {entity.names.plural}
-            </h1>
-            <p className="text-lg text-muted-foreground">
-              Browse all {entity.names.plural.toLowerCase()}
-            </p>
-          </div>
-
-          <PublicEntityGrid
-            entityType={entity.slug}
-            entitySlug={entity.slug}
-            searchParams={resolvedSearchParams}
-          />
-        </div>
-      )
-    }
-
-    // === SINGLE ITEM PAGE ===
-    // Check for theme template override first
-    const templatePath = buildTemplatePath(entity)
-    if (TemplateService.hasOverride(templatePath)) {
-      const Template = TemplateService.getComponent(templatePath)
-      if (Template) {
-        // Template handles its own data fetching and rendering
-        // Pass params in the format expected by the template
-        return <Template params={Promise.resolve({ slug })} searchParams={searchParams} />
-      }
-    }
-
-    // No template override - use default rendering
-    const item = await fetchPublishedItem(entity, slug)
-
-    if (!item) {
-      notFound()
-    }
-
-    // Resolve pattern references before rendering
-    // This expands pattern blocks inline for public display
-    const resolvedBlocks = await getResolvedBlocks(
-      item.blocks as (BlockInstance | PatternReference)[]
-    )
-
-    // Default rendering with PageRenderer
-    return (
-      <main
-        className="min-h-screen bg-background"
-        data-cy="public-entity-page"
-        data-entity={entity.slug}
-        data-slug={slug}
-      >
-        <PageRenderer
-          page={{
-            id: item.id,
-            title: item.title,
-            slug: item.slug,
-            blocks: resolvedBlocks,
-            locale: item.locale || 'en',
-          }}
-        />
-      </main>
-    )
-  }
-
-  // === FALLBACK: Try legacy entity archive resolution ===
-  // This handles entity archives like /products, /clients when they're not using basePath
-  const resolution = await resolvePublicEntityFromUrl(fullPath)
-
-  if (
-    resolution.isValidPublicEntity &&
-    resolution.hasArchivePage &&
-    resolution.entityConfig
-  ) {
-    const entityConfig = resolution.entityConfig
-
-    return (
-      <div className="container mx-auto px-4 py-8" data-cy="public-archive-page">
-        <div className="mb-8">
-          <h1 className="text-4xl font-bold text-foreground mb-4">
-            {entityConfig.names.plural}
-          </h1>
-          <p className="text-lg text-muted-foreground">
-            Browse all {entityConfig.names.plural.toLowerCase()}
-          </p>
-        </div>
-
-        <PublicEntityGrid
-          entityType={entityConfig.slug}
-          entitySlug={entityConfig.slug}
-          searchParams={resolvedSearchParams}
-        />
-      </div>
-    )
-  }
-
-  // No match found
-  notFound()
-}

package/dist/templates/app/(public)/docs/[section]/[page]/page.tsx

@@ -1,90 +0,0 @@
-import { notFound } from 'next/navigation'
-import { DOCS_REGISTRY } from '@nextsparkjs/registries/docs-registry'
-import { parseMarkdownFile } from '@nextsparkjs/core/lib/docs/parser'
-import { DocsBreadcrumbs } from '@nextsparkjs/core/components/docs/docs-breadcrumbs'
-import { DocsContent } from '@nextsparkjs/core/components/docs/docs-content'
-import { sel } from '@nextsparkjs/core/selectors'
-import { getTranslations } from 'next-intl/server'
-import path from 'path'
-import type { Metadata } from 'next'
-
-interface DocsPageProps {
-  params: Promise<{
-    section: string
-    page: string
-  }>
-}
-
-export async function generateStaticParams() {
-  const params = []
-
-  // Generate params for public docs only
-  for (const section of DOCS_REGISTRY.public) {
-    for (const page of section.pages) {
-      params.push({
-        section: section.slug,
-        page: page.slug
-      })
-    }
-  }
-
-  return params
-}
-
-export async function generateMetadata({ params }: DocsPageProps): Promise<Metadata> {
-  const resolvedParams = await params
-  const { section: sectionSlug, page: pageSlug } = resolvedParams
-
-  const section = DOCS_REGISTRY.public.find(s => s.slug === sectionSlug)
-  if (!section) return { title: 'Page Not Found' }
-
-  const page = section.pages.find(p => p.slug === pageSlug)
-  if (!page) return { title: 'Page Not Found' }
-
-  const filePath = path.join(process.cwd(), page.path)
-  const { metadata } = await parseMarkdownFile(filePath)
-
-  return {
-    title: `${metadata.title} | Documentation`,
-    description: metadata.description || `Documentation for ${metadata.title}`
-  }
-}
-
-export default async function DocsPage({ params }: DocsPageProps) {
-  const resolvedParams = await params
-  const { section: sectionSlug, page: pageSlug } = resolvedParams
-  const t = await getTranslations('docs')
-
-  // Find section in public docs
-  const section = DOCS_REGISTRY.public.find(s => s.slug === sectionSlug)
-  if (!section) notFound()
-
-  // Find page in section
-  const page = section.pages.find(p => p.slug === pageSlug)
-  if (!page) notFound()
-
-  // Parse markdown file
-  const filePath = path.join(process.cwd(), page.path)
-  const { metadata, html } = await parseMarkdownFile(filePath)
-
-  return (
-    <div className="max-w-4xl" data-cy={sel('public.docs.pageDetail')}>
-      <DocsBreadcrumbs
-        items={[
-          { label: t('breadcrumbs.home'), href: '/docs' },
-          { label: section.title },
-          { label: metadata.title }
-        ]}
-      />
-
-      <article className="mt-8 prose prose-slate dark:prose-invert max-w-none">
-        <h1 className="text-4xl font-bold mb-2">{metadata.title}</h1>
-        {metadata.description && (
-          <p className="text-xl text-muted-foreground mb-8">{metadata.description}</p>
-        )}
-
-        <DocsContent html={html} />
-      </article>
-    </div>
-  )
-}

package/dist/templates/app/(public)/docs/layout.tsx

@@ -1,25 +0,0 @@
-import { Suspense } from 'react'
-import { DocsLayout } from '@nextsparkjs/core/components/docs/docs-layout'
-import { DocsSidebar } from '@nextsparkjs/core/components/docs/docs-sidebar'
-import { DOCS_REGISTRY } from '@nextsparkjs/registries/docs-registry'
-import { sel } from '@nextsparkjs/core/selectors'
-
-export default function DocsLayoutPage({
-  children
-}: {
-  children: React.ReactNode
-}) {
-  // Only show public docs in this layout
-  const sections = DOCS_REGISTRY.public
-
-  return (
-    <DocsLayout>
-      <DocsSidebar sections={sections} />
-      <main className="flex-1 p-6 lg:p-8" data-cy={sel('public.docs.mainContent')}>
-        <Suspense fallback={<div className="animate-pulse">Loading...</div>}>
-          {children}
-        </Suspense>
-      </main>
-    </DocsLayout>
-  )
-}

package/dist/templates/app/(public)/docs/page.tsx

@@ -1,81 +0,0 @@
-import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@nextsparkjs/core/components/ui/card'
-import { DOCS_REGISTRY } from '@nextsparkjs/registries/docs-registry'
-import { sel } from '@nextsparkjs/core/selectors'
-import { BookOpen, Folder, FileText, ArrowRight } from 'lucide-react'
-import Link from 'next/link'
-import type { Metadata } from 'next'
-
-export const metadata: Metadata = {
-  title: 'Documentation',
-  description: 'Complete documentation for the application'
-}
-
-export default function DocsPage() {
-  const sections = DOCS_REGISTRY.public
-
-  return (
-    <div className="container max-w-7xl mx-auto px-4 py-8">
-      {/* Hero Section */}
-      <div className="text-center mb-12">
-        <div className="inline-flex items-center gap-2 bg-primary/10 text-primary px-3 py-1 rounded-full text-sm font-medium mb-4">
-          <BookOpen className="h-4 w-4" />
-          Documentation
-        </div>
-        <h1 className="text-4xl font-bold mb-4">
-          Documentation
-        </h1>
-        <p className="text-xl text-muted-foreground max-w-2xl mx-auto">
-          Guides and reference documentation to help you get the most out of the application.
-        </p>
-      </div>
-
-      {/* Documentation Sections */}
-      {sections.length > 0 ? (
-        <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6">
-          {sections.map((section) => (
-            <Card key={section.slug} className="h-full hover:shadow-lg transition-shadow" data-cy={sel('public.docs.sectionCard', { slug: section.slug })}>
-              <CardHeader>
-                <div className="flex items-center gap-3 mb-3">
-                  <div className="p-2 bg-primary/10 rounded-lg text-primary">
-                    <Folder className="h-6 w-6" />
-                  </div>
-                  <div>
-                    <CardTitle className="text-lg">{section.title}</CardTitle>
-                  </div>
-                </div>
-                <CardDescription>
-                  {section.pages.length} {section.pages.length === 1 ? 'page' : 'pages'}
-                </CardDescription>
-              </CardHeader>
-              <CardContent>
-                <ul className="space-y-2">
-                  {section.pages.map((page) => (
-                    <li key={page.slug}>
-                      <Link
-                        href={`/docs/${section.slug}/${page.slug}`}
-                        className="text-sm text-muted-foreground hover:text-foreground transition-colors flex items-center gap-2 group"
-                        data-cy={sel('public.docs.pageLink', { slug: page.slug })}
-                      >
-                        <FileText className="h-3 w-3" />
-                        <span className="flex-1">{page.title}</span>
-                        <ArrowRight className="h-3 w-3 opacity-0 group-hover:opacity-100 group-hover:translate-x-0.5 transition-all" />
-                      </Link>
-                    </li>
-                  ))}
-                </ul>
-              </CardContent>
-            </Card>
-          ))}
-        </div>
-      ) : (
-        <div className="text-center py-12">
-          <BookOpen className="h-12 w-12 text-muted-foreground mx-auto mb-4" />
-          <h2 className="text-xl font-semibold mb-2">No Documentation Available</h2>
-          <p className="text-muted-foreground">
-            Documentation will appear here once it is added to the project.
-          </p>
-        </div>
-      )}
-    </div>
-  )
-}

package/dist/templates/app/(public)/layout.tsx

@@ -1,41 +0,0 @@
-import type { Metadata } from "next"
-import { PublicNavbar } from '@nextsparkjs/core/components/app/layouts/PublicNavbar'
-import { PublicFooter } from '@nextsparkjs/core/components/app/layouts/PublicFooter'
-import { getTemplateOrDefault, getMetadataOrDefault } from "@nextsparkjs/core/lib/template-resolver"
-
-// ✅ MINIMAL GENERIC METADATA (cliente puede override con template)
-const defaultMetadata: Metadata = {
-  title: {
-    template: '%s | App',
-    default: 'App',
-  },
-  description: 'Application',
-}
-
-export const metadata: Metadata = getMetadataOrDefault(
-  'app/(public)/layout.tsx',
-  defaultMetadata
-)
-
-function PublicLayout({
-  children
-}: {
-  children: React.ReactNode
-}) {
-  return (
-    <div className="min-h-screen bg-background flex flex-col">
-      {/* Public Navbar */}
-      <PublicNavbar />
-
-      {/* Main Content */}
-      <main className="flex-1">
-        {children}
-      </main>
-
-      {/* Public Footer */}
-      <PublicFooter />
-    </div>
-  )
-}
-
-export default getTemplateOrDefault('app/(public)/layout.tsx', PublicLayout)

package/dist/templates/app/(public)/page.tsx

@@ -1,19 +0,0 @@
-import { redirect } from 'next/navigation'
-import { getTemplateOrDefault } from "@nextsparkjs/core/lib/template-resolver"
-
-/**
- * Default Public Home Page (CORE)
- *
- * This is the minimal CORE version that redirects to dashboard if no theme template override exists.
- * Theme templates can override this to provide custom landing pages.
- *
- * Location: app/(public)/page.tsx (CORE)
- * Override: contents/themes/[theme]/templates/(public)/page.tsx (THEME)
- */
-function DefaultPublicHome() {
-  // Si no hay template override, redirect to dashboard
-  // (Theme provides the actual landing page)
-  redirect('/dashboard')
-}
-
-export default getTemplateOrDefault('app/(public)/page.tsx', DefaultPublicHome)