create-nextblock 0.0.1

package/templates/nextblock-template/app/page.tsx

@@ -0,0 +1,109 @@
+// app/page.tsx (New Approach)
+import React from 'react';
+import { cookies, headers } from 'next/headers'; // Import headers
+import { notFound } from "next/navigation";
+import type { Metadata } from 'next';
+import PageClientContent from "./[slug]/PageClientContent"; // Reuse your existing client content component
+import { getPageDataBySlug } from "./[slug]/page.utils";   // Reuse your existing data fetching utility
+import BlockRenderer from "../components/BlockRenderer";  // Adjust path as needed
+
+const DEFAULT_LOCALE = 'en';
+const LANGUAGE_COOKIE_KEY = 'NEXT_USER_LOCALE';
+
+// Helper to determine the correct homepage slug based on locale
+async function getHomepageSlugForLocale(locale: string): Promise<string> {
+  // This logic assumes you have specific slugs for homepages, e.g., 'home' for 'en', 'accueil' for 'fr'
+  // You might fetch this from a 'settings' table or have it hardcoded
+  // Your seed data uses 'home' for EN and 'accueil' for FR.
+  // The navigation items also link '/' to these specific page IDs.
+  // We need to find the page with a specific "home" role/flag or use known slugs.
+
+  // Option 1: Hardcoded mapping (simplest if slugs are fixed)
+  if (locale === 'fr') {
+    return 'accueil';
+  }
+  return 'home'; // Default to English homepage slug
+
+  // Option 2: Query based on a "is_homepage" flag or a known title/tag in your 'pages' table
+  // (This would require schema modification or a convention)
+  // const supabase = createClient();
+  // const { data, error } = await supabase
+  //   .from('pages')
+  //   .select('slug')
+  //   .eq('language_code', locale) // Assuming you add a language_code column or join with languages
+  //   .eq('is_homepage_flag', true) // Hypothetical flag
+  //   .single();
+  // if (data?.slug) return data.slug;
+  // return locale === 'fr' ? 'accueil' : 'home'; // Fallback
+}
+
+export async function generateMetadata(): Promise<Metadata> {
+  const head = await headers();
+  let currentLocale = head.get('x-user-locale') || DEFAULT_LOCALE;
+
+  // Simplified locale detection for metadata
+  if (!head.get('x-user-locale')) {
+    const cookieStore = await cookies();
+    const cookieLocale = cookieStore.get(LANGUAGE_COOKIE_KEY)?.value;
+    if (cookieLocale) {
+      currentLocale = cookieLocale;
+    }
+  }
+
+  const homepageSlug = await getHomepageSlugForLocale(currentLocale);
+  const pageData = await getPageDataBySlug(homepageSlug);
+
+  if (!pageData) {
+    return { title: "Homepage Not Found" };
+  }
+
+  const siteUrl = process.env.NEXT_PUBLIC_SITE_URL || "";
+
+  // Simplified metadata without complex hreflang queries for better performance
+  return {
+    title: pageData.meta_title || pageData.title,
+    description: pageData.meta_description || "",
+    alternates: {
+      canonical: `${siteUrl}/`,
+    },
+  };
+}
+
+export default async function RootPage() {
+  
+  const head = await headers();
+  let currentLocale = head.get('x-user-locale') || DEFAULT_LOCALE;
+
+  // Simplified locale detection - prioritize header/cookie over database query
+  if (!head.get('x-user-locale')) {
+    const cookieStore = await cookies();
+    const cookieLocale = cookieStore.get(LANGUAGE_COOKIE_KEY)?.value;
+    if (cookieLocale) {
+      currentLocale = cookieLocale;
+    }
+    // Skip database query for default language - use fallback
+  }
+
+  const homepageSlug = await getHomepageSlugForLocale(currentLocale);
+  
+  const pageData = await getPageDataBySlug(homepageSlug);
+
+  if (!pageData) {
+    // This scenario means that for the detected locale, the corresponding homepage slug ('home' or 'accueil')
+    // does not exist or is not published.
+    // Your seed migration (20250521143933_seed_homepage_and_nav.sql) creates these.
+    // Ensure they remain published.
+    console.error(`Homepage data not found for slug: ${homepageSlug} (locale: ${currentLocale})`);
+    notFound();
+  }
+
+  const pageBlocks = pageData ? <BlockRenderer blocks={pageData.blocks} languageId={pageData.language_id} /> : null;
+
+  // Pass currentSlug as homepageSlug to PageClientContent, so it knows what content it's rendering.
+  // PageClientContent's logic for language switching will still work if the user changes language via the switcher.
+  return (
+    <PageClientContent initialPageData={pageData} currentSlug={homepageSlug}>
+      {pageBlocks}
+    </PageClientContent>
+  );
+}

package/templates/nextblock-template/app/providers.tsx

@@ -0,0 +1,43 @@
+"use client";
+
+import { ThemeProvider } from "next-themes";
+import { AuthProvider } from "@/context/AuthContext";
+import { LanguageProvider } from "@/context/LanguageContext";
+import { CurrentContentProvider } from "@/context/CurrentContentContext";
+import { TranslationsProvider } from '@nextblock-cms/utils';
+
+export function Providers({ children, ...props }: { children: React.ReactNode;[key: string]: any; }) {
+  const {
+    serverUser,
+    serverProfile,
+    serverLocale,
+    initialAvailableLanguages,
+    initialDefaultLanguage,
+    translations,
+    nonce
+  } = props;
+
+  return (
+    <AuthProvider serverUser={serverUser} serverProfile={serverProfile}>
+      <LanguageProvider
+        serverLocale={serverLocale}
+        initialAvailableLanguages={initialAvailableLanguages}
+        initialDefaultLanguage={initialDefaultLanguage}
+      >
+        <CurrentContentProvider>
+          <TranslationsProvider translations={translations} lang={serverLocale}>
+            <ThemeProvider
+              attribute="class"
+              defaultTheme="system"
+              enableSystem
+              disableTransitionOnChange
+              nonce={nonce}
+            >
+              {children}
+            </ThemeProvider>
+          </TranslationsProvider>
+        </CurrentContentProvider>
+      </LanguageProvider>
+    </AuthProvider>
+  );
+}

package/templates/nextblock-template/app/robots.txt/route.ts

@@ -0,0 +1,19 @@
+export async function GET() {
+  const siteUrl = process.env.NEXT_PUBLIC_URL || 'http://localhost:3000';
+
+  if (!process.env.NEXT_PUBLIC_URL) {
+    console.warn(
+      'Warning: NEXT_PUBLIC_URL environment variable is not set for robots.txt. Defaulting to http://localhost:3000. Ensure this is set for production.'
+    );
+  }
+
+  const robotsTxtContent = `User-agent: *
+Allow: /
+Sitemap: ${siteUrl}/sitemap.xml`;
+
+  return new Response(robotsTxtContent, {
+    headers: {
+      'Content-Type': 'text/plain',
+    },
+  });
+}

package/templates/nextblock-template/app/sitemap.xml/route.ts

@@ -0,0 +1,63 @@
+import { fetchAllPublishedPages, fetchAllPublishedPosts } from '../lib/sitemap-utils';
+import { NextResponse } from 'next/server';
+
+const baseUrl = process.env.NEXT_PUBLIC_URL || 'http://localhost:3000';
+if (!process.env.NEXT_PUBLIC_URL) {
+  console.warn("Warning: NEXT_PUBLIC_URL environment variable is not set for sitemap. Defaulting to http://localhost:3000. Ensure this is set for production.");
+}
+
+interface SitemapEntry {
+  path: string;
+  lastModified: string;
+}
+
+export async function GET() {
+  try {
+    let pages: SitemapEntry[] = [];
+    try {
+      pages = await fetchAllPublishedPages();
+    } catch (error) {
+      console.error("Error fetching published pages for sitemap:", error);
+      // Proceed with an empty array for pages
+    }
+
+    let posts: SitemapEntry[] = [];
+    try {
+      posts = await fetchAllPublishedPosts();
+    } catch (error) {
+      console.error("Error fetching published posts for sitemap:", error);
+      // Proceed with an empty array for posts
+    }
+
+    const staticRoutes: SitemapEntry[] = [
+      { path: '/', lastModified: new Date().toISOString() },
+      { path: '/blog', lastModified: new Date().toISOString() },
+    ];
+
+    const allEntries = [...staticRoutes, ...pages, ...posts];
+
+    const sitemapXml = `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+  ${allEntries
+    .map(
+      (entry) => `
+    <url>
+      <loc>${baseUrl}${entry.path}</loc>
+      <lastmod>${entry.lastModified}</lastmod>
+    </url>
+  `
+    )
+    .join('')}
+</urlset>`;
+
+    return new Response(sitemapXml, {
+      headers: {
+        'Content-Type': 'application/xml',
+        'Cache-Control': 's-maxage=3600, stale-while-revalidate=86400',
+      },
+    });
+  } catch (error) {
+    console.error("Error generating sitemap:", error);
+    return new NextResponse('Internal Server Error', { status: 500 });
+  }
+}

package/templates/nextblock-template/app/unauthorized/page.tsx

@@ -0,0 +1,27 @@
+// app/unauthorized/page.tsx
+'use client';
+import Link from 'next/link';
+import { useSearchParams } from 'next/navigation';
+
+export default function UnauthorizedPage() {
+  const searchParams = useSearchParams();
+  const reason = searchParams.get('reason');
+  const error = searchParams.get('error');
+  const path = searchParams.get('path');
+  const required = searchParams.get('required');
+
+  return (
+    <div className="flex flex-col items-center justify-center min-h-screen text-center p-4">
+      <h1 className="text-4xl font-bold text-red-600 mb-4">Access Denied</h1>
+      <p className="text-xl mb-2">You do not have the necessary permissions to view this page.</p>
+      {path && <p className="text-md text-gray-700">Requested path: <code className="bg-gray-200 p-1 rounded">{path}</code></p>}
+      {required && <p className="text-md text-gray-700">Required role(s): <code className="bg-gray-200 p-1 rounded">{required.split(',').join(' OR ')}</code></p>}
+      {reason && <p className="text-sm text-gray-500 mt-1">Details: {reason}</p>}
+      {error && <p className="text-sm text-red-500 mt-1">Error code: {error}</p>}
+      <p className="mb-6 mt-4">Please contact your administrator if you believe this is an error.</p>
+      <Link href="/" className="px-6 py-3 bg-blue-600 text-white rounded hover:bg-blue-700 transition-colors">
+        Go to Homepage
+      </Link>
+    </div>
+  );
+}