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

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

@@ -0,0 +1,190 @@
+"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

@@ -0,0 +1,378 @@
+/**
+ * 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

@@ -0,0 +1,90 @@
+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

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