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

package/dist/templates/app/(auth)/verify-email/page.tsx

@@ -1,190 +0,0 @@
-"use client";
-
-import { AlertCircle, CheckCircle, Loader2 } from "lucide-react";
-import { useSearchParams, useRouter } from "next/navigation";
-import { Suspense, useEffect, useState } from "react";
-import { Button } from '@nextsparkjs/core/components/ui/button';
-import { Alert, AlertDescription } from '@nextsparkjs/core/components/ui/alert';
-import { getTemplateOrDefaultClient } from '@nextsparkjs/registries/template-registry.client'
-import { sel } from '@nextsparkjs/core/selectors'
-
-function VerifyEmailContent() {
-  const searchParams = useSearchParams();
-  const router = useRouter();
-  const token = searchParams.get("token") || "";
-  
-  const [status, setStatus] = useState<'loading' | 'success' | 'error'>('loading');
-  const [error, setError] = useState<string | null>(null);
-
-  useEffect(() => {
-    const handleVerification = async () => {
-      if (!token) {
-        setError("No verification token provided");
-        setStatus('error');
-        return;
-      }
-
-      try {
-        // Call the Better Auth verify endpoint with special header to avoid redirect loop
-        const response = await fetch(`/api/auth/verify-email?token=${token}`, {
-          method: 'GET',
-          credentials: 'include',
-          headers: {
-            'x-verify-from-ui': 'true'
-          }
-        });
-        
-        if (!response.ok) {
-          const errorText = await response.text();
-          setError(errorText || "Email verification failed");
-          setStatus('error');
-        } else {
-          setStatus('success');
-          
-          // Create default metadata after successful verification
-          try {
-            const response = await fetch('/api/auth/session', {
-              method: 'GET',
-              credentials: 'include'
-            });
-            
-            if (response.ok) {
-              const session = await response.json();
-              if (session?.user?.id) {
-                // Create default metadata for the newly verified user
-                await fetch('/api/internal/user-metadata', {
-                  method: 'POST',
-                  headers: {
-                    'Content-Type': 'application/json',
-                  },
-                  body: JSON.stringify({
-                    userId: session.user.id,
-                    metadata: {
-                      uiPreferences: {
-                        theme: "light",
-                        sidebarCollapsed: false
-                      },
-                      securityPreferences: {
-                        twoFactorEnabled: false,
-                        loginAlertsEnabled: true
-                      },
-                      notificationsPreferences: {
-                        pushEnabled: true,
-                        loginAlertsEmail: true,
-                        loginAlertsPush: true,
-                        passwordChangesEmail: true,
-                        passwordChangesPush: true,
-                        suspiciousActivityEmail: true,
-                        suspiciousActivityPush: true,
-                        mentionsEmail: true,
-                        mentionsPush: true,
-                        projectUpdatesEmail: true,
-                        projectUpdatesPush: false,
-                        teamInvitesEmail: true,
-                        teamInvitesPush: true,
-                        newsletterEmail: false,
-                        newsletterPush: false,
-                        promotionsEmail: false,
-                        promotionsPush: false,
-                        featureAnnouncementsEmail: true,
-                        featureAnnouncementsPush: false
-                      }
-                    }
-                  })
-                });
-                console.log('Default metadata created for verified user:', session.user.id);
-              }
-            }
-          } catch (metaError) {
-            console.error('Error creating default metadata:', metaError);
-            // Don't fail the verification if metadata creation fails
-          }
-          
-          // Redirect after successful verification
-          setTimeout(() => {
-            router.push('/dashboard');
-          }, 2000);
-        }
-      } catch {
-        setError("An unexpected error occurred");
-        setStatus('error');
-      }
-    };
-
-    handleVerification();
-  }, [token, router]);
-
-  if (status === 'loading') {
-    return (
-      <div className="space-y-4" data-cy={sel('auth.verifyEmail.loading')}>
-        <div className="text-center">
-          <h2 className="text-xl font-semibold">Verifying Email</h2>
-          <p className="text-sm text-muted-foreground mt-2">Please wait while we verify your email address</p>
-        </div>
-        <div className="flex justify-center py-6">
-          <Loader2 className="h-8 w-8 animate-spin text-muted-foreground" />
-        </div>
-      </div>
-    );
-  }
-
-  if (status === 'success') {
-    return (
-      <div className="space-y-4" data-cy={sel('auth.verifyEmail.success')}>
-        <div className="text-center">
-          <div className="flex justify-center mb-2">
-            <CheckCircle className="h-12 w-12 text-primary" />
-          </div>
-          <h2 className="text-xl font-semibold">Email Verified</h2>
-          <p className="text-sm text-muted-foreground mt-2">Your email has been successfully verified</p>
-        </div>
-        <Alert>
-          <AlertDescription>
-            Redirecting you to the dashboard...
-          </AlertDescription>
-        </Alert>
-      </div>
-    );
-  }
-
-  return (
-    <div className="space-y-4" data-cy={sel('auth.verifyEmail.error')}>
-      <div className="text-center">
-        <div className="flex justify-center mb-2">
-          <AlertCircle className="h-12 w-12 text-destructive" />
-        </div>
-        <h2 className="text-xl font-semibold">Verification Failed</h2>
-        <p className="text-sm text-muted-foreground mt-2">We couldn&apos;t verify your email address</p>
-      </div>
-      {error && (
-        <Alert variant="destructive" data-cy={sel('auth.verifyEmail.errorMessage')}>
-          <AlertDescription>{error}</AlertDescription>
-        </Alert>
-      )}
-      <div className="flex gap-2">
-        <Button onClick={() => router.push('/signup')} variant="outline" className="flex-1" data-cy={sel('auth.verifyEmail.backSignup')}>
-          Back to Sign Up
-        </Button>
-        <Button onClick={() => router.push('/login')} className="flex-1" data-cy={sel('auth.verifyEmail.goLogin')}>
-          Go to Login
-        </Button>
-      </div>
-    </div>
-  );
-}
-
-function VerifyEmailPage() {
-  return (
-    <Suspense fallback={
-      <div className="flex justify-center py-8">
-        <Loader2 className="h-8 w-8 animate-spin text-muted-foreground" />
-      </div>
-    }>
-      <VerifyEmailContent />
-    </Suspense>
-  );
-}
-
-export const dynamic = 'force-dynamic';
-
-export default getTemplateOrDefaultClient('app/(auth)/verify-email/page.tsx', VerifyEmailPage)

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