create-nextjs-stack 0.1.0

package/templates/web/src/lib/seo/metadata.ts

@@ -0,0 +1,103 @@
+import { Metadata } from 'next';
+import { PageSEOConfig } from './seo.types';
+import { seoConfig } from './seo.config';
+
+/**
+ * Generate Next.js Metadata from SEO Config
+ * @param pageConfig - Page-specific SEO configuration
+ * @returns Next.js Metadata object
+ */
+export function generateMetadata(pageConfig: PageSEOConfig): Metadata {
+    const { site } = seoConfig;
+
+    const metadata: Metadata = {
+        title: pageConfig.title,
+        description: pageConfig.description,
+        keywords: pageConfig.keywords,
+
+        // Robots
+        robots: pageConfig.robots
+            ? {
+                index: pageConfig.robots.index ?? true,
+                follow: pageConfig.robots.follow ?? true,
+                googleBot: pageConfig.robots.googleBot,
+            }
+            : undefined,
+
+        // Open Graph
+        openGraph: {
+            title: pageConfig.openGraph?.title || pageConfig.title,
+            description: pageConfig.openGraph?.description || pageConfig.description,
+            siteName: site.siteName,
+            locale: site.defaultLocale,
+            type: pageConfig.openGraph?.type || 'website',
+            url: pageConfig.canonical || site.siteUrl,
+            images: pageConfig.openGraph?.images?.map((img) => ({
+                url: img,
+                width: 1200,
+                height: 630,
+                alt: site.siteName,
+            })) || [
+                    {
+                        url: site.defaultOGImage,
+                        width: 1200,
+                        height: 630,
+                        alt: site.siteName,
+                    },
+                ],
+        },
+
+        // Twitter
+        twitter: {
+            card: pageConfig.twitter?.card || 'summary_large_image',
+            title: pageConfig.twitter?.title || pageConfig.title,
+            description: pageConfig.twitter?.description || pageConfig.description,
+            creator: site.twitterHandle,
+            images: pageConfig.twitter?.images?.[0] || site.defaultOGImage,
+        },
+
+        // Alternates
+        alternates: pageConfig.alternates
+            ? {
+                canonical: pageConfig.canonical,
+                languages: pageConfig.alternates.languages,
+            }
+            : pageConfig.canonical
+                ? { canonical: pageConfig.canonical }
+                : undefined,
+
+        // Additional Meta Tags
+        other: {
+            'fb:app_id': site.facebookAppId || '',
+        },
+    };
+
+    return metadata;
+}
+
+/**
+ * Generate JSON-LD Structured Data for Organization
+ */
+export function generateOrganizationSchema() {
+    const { site } = seoConfig;
+
+    return {
+        '@context': 'https://schema.org',
+        '@type': 'Organization',
+        name: site.siteName,
+        url: site.siteUrl,
+        logo: `${site.siteUrl}/images/logo.png`,
+        description:
+            'Eurodeco Panel Systems GmbH - Innovative Panel-Systeme für Architektur der Zukunft',
+        contactPoint: {
+            '@type': 'ContactPoint',
+            contactType: 'Sales',
+            availableLanguage: ['German', 'English'],
+        },
+        sameAs: [
+            // Sosyal medya linklerinizi buraya ekleyin
+            // 'https://www.linkedin.com/company/eurodeco-panel-systems',
+            // 'https://www.instagram.com/eurodeco',
+        ],
+    };
+}

package/templates/web/src/lib/seo/seo.config.ts

@@ -0,0 +1,161 @@
+import { SEOConfig } from './seo.types';
+
+/**
+ * Centralized SEO Configuration
+ * Tüm sayfa SEO ayarları burada yönetilir
+ */
+export const seoConfig: SEOConfig = {
+    site: {
+        siteName: 'Eurodeco Panel Systems GmbH',
+        siteUrl: 'https://www.eurodecopanel.de',
+        defaultLocale: 'de',
+        locales: ['de', 'en'],
+        defaultOGImage: '/images/og-default.jpg',
+        twitterHandle: '@eurodecopanel', // Placeholder handle
+    },
+
+    pages: {
+        // Home Page SEO
+        home: {
+            title: 'Eurodeco Panel Systems GmbH - Innovative Panel-Systeme',
+            description:
+                'Eurodeco Panel Systems GmbH entwickelt und vertreibt moderne Hochleistungs-Paneelsysteme für anspruchsvolle Architektur, Innenausbau und Gewerbeprojekte.',
+            keywords: [
+                'Eurodeco',
+                'Panel-Systeme',
+                'Wandpaneele',
+                'Deckenpaneele',
+                'Brandschutz',
+                'Leichtbau',
+                'Architektur',
+                'Gewerbeprojekte',
+            ],
+            openGraph: {
+                title: 'Eurodeco Panel Systems GmbH - Innovative Panel-Systeme',
+                description:
+                    'Entwickelt und vertreibt moderne Hochleistungs-Paneelsysteme für anspruchsvolle Architektur.',
+                images: ['/images/og-home.jpg'],
+                type: 'website',
+            },
+            twitter: {
+                card: 'summary_large_image',
+                title: 'Eurodeco Panel Systems GmbH - Innovative Panel-Systeme',
+                description:
+                    'Entwickelt und vertreibt moderne Hochleistungs-Paneelsysteme für anspruchsvolle Architektur.',
+                images: ['/images/twitter-home.jpg'],
+            },
+            robots: {
+                index: true,
+                follow: true,
+                googleBot: {
+                    index: true,
+                    follow: true,
+                },
+            },
+        },
+
+        // About Page SEO
+        about: {
+            title: 'Über Uns - Eurodeco Panel Systems GmbH',
+            description:
+                'Erfahren Sie mehr über Eurodeco Panel Systems GmbH, unsere Mission, Vision und Technologie für moderne Paneelsysteme.',
+            keywords: [
+                'Über Eurodeco',
+                'Mission',
+                'Vision',
+                'Technologie',
+                'Paneelsysteme',
+                'Unternehmensprofil',
+            ],
+            canonical: 'https://www.eurodecopanel.de/about',
+            openGraph: {
+                title: 'Über Uns - Eurodeco Panel Systems GmbH',
+                description:
+                    'Erfahren Sie mehr über Eurodeco Panel Systems GmbH und unsere innovativen Lösungen.',
+                images: ['/images/og-about.jpg'],
+                type: 'website',
+            },
+            robots: {
+                index: true,
+                follow: true,
+            },
+        },
+
+        // Works/Projects Page SEO
+        works: {
+            title: 'Referenzen - Eurodeco Panel Systems GmbH',
+            description:
+                'Entdecken Sie unsere erfolgreichen Projekte und Referenzen in den Bereichen Gewerbe, Büro, Hotel und öffentliche Gebäude.',
+            keywords: [
+                'Referenzen',
+                'Projekte',
+                'Eurodeco Projekte',
+                'Architektur Referenzen',
+                'Bauprojekte',
+            ],
+            canonical: 'https://www.eurodecopanel.de/references',
+            openGraph: {
+                title: 'Referenzen - Eurodeco Panel Systems GmbH',
+                description:
+                    'Entdecken Sie unsere erfolgreichen Projekte und Referenzen.',
+                images: ['/images/og-works.jpg'],
+                type: 'website',
+            },
+            robots: {
+                index: true,
+                follow: true,
+            },
+        },
+
+        // Blog Page SEO (Keeping structurally but updating content generic/german if needed, or removing if not in list. Task.md didn't ask to remove, just update config. I'll translate to German generic).
+        blog: {
+            title: 'Aktuelles - Eurodeco Panel Systems GmbH',
+            description:
+                'Neuigkeiten und Trends zu Paneelsystemen, Architektur und Innovationen von Eurodeco.',
+            keywords: [
+                'Eurodeco News',
+                'Architektur Trends',
+                'Paneel Innovationen',
+                'Baubranche',
+            ],
+            canonical: 'https://www.eurodecopanel.de/blog',
+            openGraph: {
+                title: 'Aktuelles - Eurodeco Panel Systems GmbH',
+                description:
+                    'Neuigkeiten und Trends zu Paneelsystemen und Architektur.',
+                images: ['/images/og-blog.jpg'],
+                type: 'website',
+            },
+            robots: {
+                index: true,
+                follow: true,
+            },
+        },
+
+        // Contact Page SEO
+        contact: {
+            title: 'Kontakt - Eurodeco Panel Systems GmbH',
+            description:
+                'Kontaktieren Sie Eurodeco Panel Systems GmbH für Ihr nächstes Architektur- oder Bauprojekt. Wir freuen uns auf den Austausch.',
+            keywords: [
+                'Kontakt Eurodeco',
+                'Anfrage',
+                'Projekt starten',
+                'Eurodeco Adresse',
+                'Eurodeco Email',
+            ],
+            canonical: 'https://www.eurodecopanel.de/contact',
+            openGraph: {
+                title: 'Kontakt - Eurodeco Panel Systems GmbH',
+                description:
+                    'Kontaktieren Sie uns für Ihr nächstes Projekt.',
+                images: ['/images/og-contact.jpg'],
+                type: 'website',
+            },
+            robots: {
+                index: true,
+                follow: true,
+            },
+        },
+    },
+};

package/templates/web/src/lib/seo/seo.types.ts

@@ -0,0 +1,76 @@
+
+
+/**
+ * SEO Configuration for individual pages
+ */
+export interface PageSEOConfig {
+    /** Page title */
+    title: string;
+    /** Page description */
+    description: string;
+    /** Page keywords */
+    keywords?: string[];
+    /** Canonical URL */
+    canonical?: string;
+    /** Open Graph specific overrides */
+    openGraph?: {
+        title?: string;
+        description?: string;
+        images?: string[];
+        type?: 'website' | 'article';
+    };
+    /** Twitter Card specific overrides */
+    twitter?: {
+        card?: 'summary' | 'summary_large_image' | 'app' | 'player';
+        title?: string;
+        description?: string;
+        images?: string[];
+    };
+    /** Robots meta tag */
+    robots?: {
+        index?: boolean;
+        follow?: boolean;
+        googleBot?: {
+            index?: boolean;
+            follow?: boolean;
+        };
+    };
+    /** Alternate languages */
+    alternates?: {
+        languages?: Record<string, string>;
+    };
+}
+
+/**
+ * Site-wide SEO Configuration
+ */
+export interface SiteSEOConfig {
+    /** Site name */
+    siteName: string;
+    /** Base URL */
+    siteUrl: string;
+    /** Default locale */
+    defaultLocale: string;
+    /** Available locales */
+    locales: string[];
+    /** Default OG image */
+    defaultOGImage: string;
+    /** Twitter handle */
+    twitterHandle?: string;
+    /** Facebook App ID */
+    facebookAppId?: string;
+}
+
+/**
+ * Complete SEO Configuration including site config and page configs
+ */
+export interface SEOConfig {
+    site: SiteSEOConfig;
+    pages: {
+        home: PageSEOConfig;
+        about: PageSEOConfig;
+        works: PageSEOConfig;
+        blog: PageSEOConfig;
+        contact: PageSEOConfig;
+    };
+}

package/templates/web/src/lib/services/categories.service.ts

@@ -0,0 +1,38 @@
+import { getServerClient } from "@/lib/supabase/server";
+
+export class CategoryService {
+  private static table = "categories";
+
+  static async getAll() {
+    const supabase = await getServerClient();
+    const { data, error } = await supabase
+      .from(this.table)
+      .select("*")
+      .eq("published", true)
+      .order("title");
+
+    if (error) {
+      console.error(`Error fetching ${this.table}:`, error);
+      return [];
+    }
+
+    return data;
+  }
+
+  static async getBySlug(slug: string) {
+    const supabase = await getServerClient();
+    const { data, error } = await supabase
+      .from(this.table)
+      .select("*")
+      .eq("slug", slug)
+      .eq("published", true)
+      .single();
+
+    if (error) {
+      console.error(`Error fetching ${this.table} ${slug}:`, error);
+      return null;
+    }
+
+    return data;
+  }
+}

package/templates/web/src/lib/services/categoryService.ts

@@ -0,0 +1,251 @@
+import { getBrowserClient } from '@/lib/supabase/client';
+import { TABLE_NAMES, CACHE_TIMES } from '@/lib/supabase/constants';
+import { memoryCache } from '@/lib/utils/cache';
+import { perMinuteLimiter } from '@/lib/utils/rate-limiter';
+import type { Category, CategoryWithChildren } from '@/lib/supabase/types';
+
+/**
+ * Category Service - Handles all category-related database operations
+ * Implements singleton pattern with caching and rate limiting
+ */
+export class CategoryService {
+  private static instance: CategoryService;
+
+  private constructor() {}
+
+  /**
+   * Get singleton instance
+   */
+  static getInstance(): CategoryService {
+    if (!CategoryService.instance) {
+      CategoryService.instance = new CategoryService();
+    }
+    return CategoryService.instance;
+  }
+
+  /**
+   * Get all published categories
+   */
+  async getAll(): Promise<Category[]> {
+    const cacheKey = 'categories:all';
+
+    // Check memory cache
+    const cached = memoryCache.get<Category[]>(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    // Rate limiting
+    const allowed = await perMinuteLimiter.checkLimit('categories:getAll');
+    if (!allowed) {
+      throw new Error('Rate limit exceeded. Please try again later.');
+    }
+
+    // Fetch from database
+    const supabase = getBrowserClient();
+    const { data, error } = await supabase
+      .from(TABLE_NAMES.CATEGORIES)
+      .select('*')
+      .eq('published', true)
+      .order('created_at', { ascending: false });
+
+    if (error) {
+      console.error('[CategoryService] Error fetching categories:', error);
+      throw new Error(`Failed to fetch categories: ${error.message}`);
+    }
+
+    // Cache result
+    memoryCache.set(cacheKey, data, CACHE_TIMES.CATEGORIES);
+
+    return data;
+  }
+
+  /**
+   * Get category by slug
+   */
+  async getBySlug(slug: string): Promise<Category | null> {
+    const cacheKey = `categories:slug:${slug}`;
+
+    const cached = memoryCache.get<Category>(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    const allowed = await perMinuteLimiter.checkLimit('categories:getBySlug');
+    if (!allowed) {
+      throw new Error('Rate limit exceeded. Please try again later.');
+    }
+
+    const supabase = getBrowserClient();
+    const { data, error } = await supabase
+      .from(TABLE_NAMES.CATEGORIES)
+      .select('*')
+      .eq('slug', slug)
+      .eq('published', true)
+      .single();
+
+    if (error) {
+      if (error.code === 'PGRST116') {
+        // Not found
+        return null;
+      }
+      console.error('[CategoryService] Error fetching category:', error);
+      throw new Error(`Failed to fetch category: ${error.message}`);
+    }
+
+    memoryCache.set(cacheKey, data, CACHE_TIMES.CATEGORIES);
+    return data;
+  }
+
+  /**
+   * Get featured categories
+   */
+  async getFeatured(): Promise<Category[]> {
+    const cacheKey = 'categories:featured';
+
+    const cached = memoryCache.get<Category[]>(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    const allowed = await perMinuteLimiter.checkLimit('categories:getFeatured');
+    if (!allowed) {
+      throw new Error('Rate limit exceeded. Please try again later.');
+    }
+
+    const supabase = getBrowserClient();
+    const { data, error } = await supabase
+      .from(TABLE_NAMES.CATEGORIES)
+      .select('*')
+      .eq('published', true)
+      .eq('featured', true)
+      .order('created_at', { ascending: false });
+
+    if (error) {
+      console.error('[CategoryService] Error fetching featured categories:', error);
+      throw new Error(`Failed to fetch featured categories: ${error.message}`);
+    }
+
+    memoryCache.set(cacheKey, data, CACHE_TIMES.CATEGORIES);
+    return data;
+  }
+
+  /**
+   * Get sub-categories of a parent category
+   */
+  async getSubCategories(parentId: string): Promise<Category[]> {
+    const cacheKey = `categories:parent:${parentId}`;
+
+    const cached = memoryCache.get<Category[]>(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    const supabase = getBrowserClient();
+    const { data, error } = await supabase
+      .from(TABLE_NAMES.CATEGORIES)
+      .select('*')
+      .eq('parent_id', parentId)
+      .eq('published', true)
+      .order('created_at', { ascending: false });
+
+    if (error) {
+      console.error('[CategoryService] Error fetching sub-categories:', error);
+      throw new Error(`Failed to fetch sub-categories: ${error.message}`);
+    }
+
+    memoryCache.set(cacheKey, data, CACHE_TIMES.CATEGORIES);
+    return data;
+  }
+
+  /**
+   * Build hierarchical category tree
+   */
+  async getTree(): Promise<CategoryWithChildren[]> {
+    const cacheKey = 'categories:tree';
+
+    const cached = memoryCache.get<CategoryWithChildren[]>(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    // Get all categories
+    const categories = await this.getAll();
+
+    // Build category map
+    const categoryMap = new Map<string, CategoryWithChildren>();
+    categories.forEach((cat) => {
+      categoryMap.set(cat.id, { ...cat, children: [] });
+    });
+
+    // Build tree structure
+    const tree: CategoryWithChildren[] = [];
+    categories.forEach((cat) => {
+      const category = categoryMap.get(cat.id)!;
+      
+      if (cat.parent_id) {
+        const parent = categoryMap.get(cat.parent_id);
+        if (parent) {
+          if (!parent.children) {
+            parent.children = [];
+          }
+          parent.children.push(category);
+        }
+      } else {
+        // Root level category
+        tree.push(category);
+      }
+    });
+
+    memoryCache.set(cacheKey, tree, CACHE_TIMES.CATEGORIES);
+    return tree;
+  }
+
+  /**
+   * Get category by ID
+   */
+  async getById(id: string): Promise<Category | null> {
+    const cacheKey = `categories:id:${id}`;
+
+    const cached = memoryCache.get<Category>(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    const supabase = getBrowserClient();
+    const { data, error } = await supabase
+      .from(TABLE_NAMES.CATEGORIES)
+      .select('*')
+      .eq('id', id)
+      .eq('published', true)
+      .single();
+
+    if (error) {
+      if (error.code === 'PGRST116') {
+        return null;
+      }
+      console.error('[CategoryService] Error fetching category by ID:', error);
+      throw new Error(`Failed to fetch category: ${error.message}`);
+    }
+
+    memoryCache.set(cacheKey, data, CACHE_TIMES.CATEGORIES);
+    return data;
+  }
+
+  /**
+   * Invalidate all category caches
+   */
+  invalidateCache(): void {
+    memoryCache.invalidate('categories:');
+  }
+
+  /**
+   * Invalidate specific category cache
+   */
+  invalidateCategoryCache(slug: string): void {
+    memoryCache.invalidateKey(`categories:slug:${slug}`);
+  }
+}
+
+// Export singleton instance
+export const categoryService = CategoryService.getInstance();