create-nextjs-stack 0.1.0

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

@@ -0,0 +1,132 @@
+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 { Client } from '@/lib/supabase/types';
+
+/**
+ * Client Service - Handles all client-related database operations
+ * Implements singleton pattern with caching and rate limiting
+ */
+export class ClientService {
+  private static instance: ClientService;
+
+  private constructor() {}
+
+  static getInstance(): ClientService {
+    if (!ClientService.instance) {
+      ClientService.instance = new ClientService();
+    }
+    return ClientService.instance;
+  }
+
+  /**
+   * Get all published clients ordered by sort_order
+   */
+  async getAll(): Promise<Client[]> {
+    const cacheKey = 'clients:all';
+
+    const cached = memoryCache.get<Client[]>(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    const allowed = await perMinuteLimiter.checkLimit('clients:getAll');
+    if (!allowed) {
+      throw new Error('Rate limit exceeded. Please try again later.');
+    }
+
+    const supabase = getBrowserClient();
+    const { data, error } = await supabase
+      .from(TABLE_NAMES.CLIENTS)
+      .select('*')
+      .eq('published', true)
+      .order('sort_order', { ascending: true });
+
+    if (error) {
+      console.error('[ClientService] Error fetching clients:', error);
+      throw new Error(`Failed to fetch clients: ${error.message}`);
+    }
+
+    memoryCache.set(cacheKey, data, CACHE_TIMES.CLIENTS);
+    return data;
+  }
+
+  /**
+   * Get client by name
+   */
+  async getByName(name: string): Promise<Client | null> {
+    const cacheKey = `clients:name:${name}`;
+
+    const cached = memoryCache.get<Client>(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    const supabase = getBrowserClient();
+    const { data, error } = await supabase
+      .from(TABLE_NAMES.CLIENTS)
+      .select('*')
+      .eq('name', name)
+      .eq('published', true)
+      .single();
+
+    if (error) {
+      if (error.code === 'PGRST116') {
+        return null;
+      }
+      console.error('[ClientService] Error fetching client:', error);
+      throw new Error(`Failed to fetch client: ${error.message}`);
+    }
+
+    memoryCache.set(cacheKey, data, CACHE_TIMES.CLIENTS);
+    return data;
+  }
+
+  /**
+   * Get client by ID
+   */
+  async getById(id: string): Promise<Client | null> {
+    const cacheKey = `clients:id:${id}`;
+
+    const cached = memoryCache.get<Client>(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    const supabase = getBrowserClient();
+    const { data, error } = await supabase
+      .from(TABLE_NAMES.CLIENTS)
+      .select('*')
+      .eq('id', id)
+      .eq('published', true)
+      .single();
+
+    if (error) {
+      if (error.code === 'PGRST116') {
+        return null;
+      }
+      console.error('[ClientService] Error fetching client by ID:', error);
+      throw new Error(`Failed to fetch client: ${error.message}`);
+    }
+
+    memoryCache.set(cacheKey, data, CACHE_TIMES.CLIENTS);
+    return data;
+  }
+
+  /**
+   * Invalidate all client caches
+   */
+  invalidateCache(): void {
+    memoryCache.invalidate('clients:');
+  }
+
+  /**
+   * Invalidate specific client cache
+   */
+  invalidateClientCache(name: string): void {
+    memoryCache.invalidateKey(`clients:name:${name}`);
+  }
+}
+
+export const clientService = ClientService.getInstance();

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

@@ -0,0 +1,20 @@
+import { getServerClient } from "@/lib/supabase/server";
+
+export class ClientService {
+  private static table = "clients";
+
+  static async getAll() {
+    const supabase = await getServerClient();
+    const { data, error } = await supabase
+      .from(this.table)
+      .select("*")
+      .order("name");
+
+    if (error) {
+      console.error(`Error fetching ${this.table}:`, error);
+      return [];
+    }
+
+    return data;
+  }
+}

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

@@ -0,0 +1,261 @@
+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 { Product, ProductWithCategory } from '@/lib/supabase/types';
+
+interface GetProductsOptions {
+  limit?: number;
+  offset?: number;
+  categoryId?: string;
+  featured?: boolean;
+}
+
+/**
+ * Product Service - Handles all product-related database operations
+ * Implements singleton pattern with caching and rate limiting
+ */
+export class ProductService {
+  private static instance: ProductService;
+
+  private constructor() {}
+
+  static getInstance(): ProductService {
+    if (!ProductService.instance) {
+      ProductService.instance = new ProductService();
+    }
+    return ProductService.instance;
+  }
+
+  /**
+   * Get all published products with optional filtering
+   */
+  async getAll(options: GetProductsOptions = {}): Promise<Product[]> {
+    const { limit = 100, offset = 0, categoryId, featured } = options;
+    const cacheKey = `products:all:${limit}:${offset}:${categoryId || 'none'}:${featured || 'all'}`;
+
+    const cached = memoryCache.get<Product[]>(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    const allowed = await perMinuteLimiter.checkLimit('products:getAll');
+    if (!allowed) {
+      throw new Error('Rate limit exceeded. Please try again later.');
+    }
+
+    const supabase = getBrowserClient();
+    let query = supabase
+      .from(TABLE_NAMES.PRODUCTS)
+      .select('*')
+      .eq('published', true)
+      .order('created_at', { ascending: false })
+      .range(offset, offset + limit - 1);
+
+    if (categoryId) {
+      query = query.eq('category_id', categoryId);
+    }
+
+    if (featured !== undefined) {
+      query = query.eq('featured', featured);
+    }
+
+    const { data, error } = await query;
+
+    if (error) {
+      console.error('[ProductService] Error fetching products:', error);
+      throw new Error(`Failed to fetch products: ${error.message}`);
+    }
+
+    memoryCache.set(cacheKey, data, CACHE_TIMES.PRODUCTS);
+    return data;
+  }
+
+  /**
+   * Get product by slug with category information
+   */
+  async getBySlug(slug: string): Promise<ProductWithCategory | null> {
+    const cacheKey = `products:slug:${slug}`;
+
+    const cached = memoryCache.get<ProductWithCategory>(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    const allowed = await perMinuteLimiter.checkLimit('products:getBySlug');
+    if (!allowed) {
+      throw new Error('Rate limit exceeded. Please try again later.');
+    }
+
+    const supabase = getBrowserClient();
+    const { data, error } = await supabase
+      .from(TABLE_NAMES.PRODUCTS)
+      .select(`
+        *,
+        category:categories(*)
+      `)
+      .eq('slug', slug)
+      .eq('published', true)
+      .single();
+
+    if (error) {
+      if (error.code === 'PGRST116') {
+        return null;
+      }
+      console.error('[ProductService] Error fetching product:', error);
+      throw new Error(`Failed to fetch product: ${error.message}`);
+    }
+
+    const productWithCategory = data as unknown as ProductWithCategory;
+    memoryCache.set(cacheKey, productWithCategory, CACHE_TIMES.PRODUCTS);
+    return productWithCategory;
+  }
+
+  /**
+   * Get featured products
+   */
+  async getFeatured(): Promise<Product[]> {
+    return this.getAll({ featured: true });
+  }
+
+  /**
+   * Get products by category
+   */
+  async getByCategory(categoryId: string, limit = 100): Promise<Product[]> {
+    return this.getAll({ categoryId, limit });
+  }
+
+  /**
+   * Get related products (same category, excluding current product)
+   */
+  async getRelated(productId: string, categoryId: string, limit = 4): Promise<Product[]> {
+    const cacheKey = `products:related:${productId}:${limit}`;
+
+    const cached = memoryCache.get<Product[]>(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    const supabase = getBrowserClient();
+    const { data, error } = await supabase
+      .from(TABLE_NAMES.PRODUCTS)
+      .select('*')
+      .eq('category_id', categoryId)
+      .eq('published', true)
+      .neq('id', productId)
+      .limit(limit);
+
+    if (error) {
+      console.error('[ProductService] Error fetching related products:', error);
+      throw new Error(`Failed to fetch related products: ${error.message}`);
+    }
+
+    memoryCache.set(cacheKey, data, CACHE_TIMES.PRODUCTS);
+    return data;
+  }
+
+  /**
+   * Get product by ID
+   */
+  async getById(id: string): Promise<Product | null> {
+    const cacheKey = `products:id:${id}`;
+
+    const cached = memoryCache.get<Product>(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    const supabase = getBrowserClient();
+    const { data, error } = await supabase
+      .from(TABLE_NAMES.PRODUCTS)
+      .select('*')
+      .eq('id', id)
+      .eq('published', true)
+      .single();
+
+    if (error) {
+      if (error.code === 'PGRST116') {
+        return null;
+      }
+      console.error('[ProductService] Error fetching product by ID:', error);
+      throw new Error(`Failed to fetch product: ${error.message}`);
+    }
+
+    memoryCache.set(cacheKey, data, CACHE_TIMES.PRODUCTS);
+    return data;
+  }
+
+  /**
+   * Get multiple products by IDs
+   */
+  async getByIds(ids: string[]): Promise<Product[]> {
+    if (ids.length === 0) {
+      return [];
+    }
+
+    const cacheKey = `products:ids:${ids.sort().join(',')}`;
+
+    const cached = memoryCache.get<Product[]>(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    const supabase = getBrowserClient();
+    const { data, error } = await supabase
+      .from(TABLE_NAMES.PRODUCTS)
+      .select('*')
+      .in('id', ids)
+      .eq('published', true);
+
+    if (error) {
+      console.error('[ProductService] Error fetching products by IDs:', error);
+      throw new Error(`Failed to fetch products: ${error.message}`);
+    }
+
+    memoryCache.set(cacheKey, data, CACHE_TIMES.PRODUCTS);
+    return data;
+  }
+
+  /**
+   * Get all product slugs for static generation
+   */
+  async getAllSlugs(): Promise<string[]> {
+    const cacheKey = 'products:slugs:all';
+
+    const cached = memoryCache.get<string[]>(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    const supabase = getBrowserClient();
+    const { data, error } = await supabase
+      .from(TABLE_NAMES.PRODUCTS)
+      .select('slug')
+      .eq('published', true);
+
+    if (error) {
+      console.error('[ProductService] Error fetching product slugs:', error);
+      throw new Error(`Failed to fetch product slugs: ${error.message}`);
+    }
+
+    const slugs = (data as { slug: string }[]).map((item) => item.slug);
+    memoryCache.set(cacheKey, slugs, CACHE_TIMES.PRODUCTS);
+    return slugs;
+  }
+
+  /**
+   * Invalidate all product caches
+   */
+  invalidateCache(): void {
+    memoryCache.invalidate('products:');
+  }
+
+  /**
+   * Invalidate specific product cache
+   */
+  invalidateProductCache(slug: string): void {
+    memoryCache.invalidateKey(`products:slug:${slug}`);
+  }
+}
+
+export const productService = ProductService.getInstance();

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

@@ -0,0 +1,38 @@
+import { getServerClient } from "@/lib/supabase/server";
+
+export class ProductService {
+  private static table = "products";
+
+  static async getAll() {
+    const supabase = await getServerClient();
+    const { data, error } = await supabase
+      .from(this.table)
+      .select("*, categories(title, slug)")
+      .eq("published", true)
+      .order("created_at", { ascending: false });
+
+    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("*, categories(title, slug)")
+      .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/projectService.ts

@@ -0,0 +1,234 @@
+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 { Project, ProjectWithProducts } from '@/lib/supabase/types';
+import { productService } from './productService';
+
+interface GetProjectsOptions {
+  limit?: number;
+  offset?: number;
+  year?: number;
+  featured?: boolean;
+}
+
+/**
+ * Project Service - Handles all project-related database operations
+ * Implements singleton pattern with caching and rate limiting
+ */
+export class ProjectService {
+  private static instance: ProjectService;
+
+  private constructor() {}
+
+  static getInstance(): ProjectService {
+    if (!ProjectService.instance) {
+      ProjectService.instance = new ProjectService();
+    }
+    return ProjectService.instance;
+  }
+
+  /**
+   * Get all published projects with optional filtering
+   */
+  async getAll(options: GetProjectsOptions = {}): Promise<Project[]> {
+    const { limit = 100, offset = 0, year, featured } = options;
+    const cacheKey = `projects:all:${limit}:${offset}:${year || 'all'}:${featured || 'all'}`;
+
+    const cached = memoryCache.get<Project[]>(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    const allowed = await perMinuteLimiter.checkLimit('projects:getAll');
+    if (!allowed) {
+      throw new Error('Rate limit exceeded. Please try again later.');
+    }
+
+    const supabase = getBrowserClient();
+    let query = supabase
+      .from(TABLE_NAMES.PROJECTS)
+      .select('*')
+      .eq('published', true)
+      .order('year', { ascending: false })
+      .order('created_at', { ascending: false })
+      .range(offset, offset + limit - 1);
+
+    if (year !== undefined) {
+      query = query.eq('year', year);
+    }
+
+    if (featured !== undefined) {
+      query = query.eq('featured', featured);
+    }
+
+    const { data, error } = await query;
+
+    if (error) {
+      console.error('[ProjectService] Error fetching projects:', error);
+      throw new Error(`Failed to fetch projects: ${error.message}`);
+    }
+
+    memoryCache.set(cacheKey, data, CACHE_TIMES.PROJECTS);
+    return data as Project[];
+  }
+
+  /**
+   * Get project by slug with related products
+   */
+  async getBySlug(slug: string): Promise<ProjectWithProducts | null> {
+    const cacheKey = `projects:slug:${slug}`;
+
+    const cached = memoryCache.get<ProjectWithProducts>(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    const allowed = await perMinuteLimiter.checkLimit('projects:getBySlug');
+    if (!allowed) {
+      throw new Error('Rate limit exceeded. Please try again later.');
+    }
+
+    const supabase = getBrowserClient();
+    const { data, error } = await supabase
+      .from(TABLE_NAMES.PROJECTS)
+      .select('*')
+      .eq('slug', slug)
+      .eq('published', true)
+      .single();
+
+    if (error) {
+      if (error.code === 'PGRST116') {
+        return null;
+      }
+      console.error('[ProjectService] Error fetching project:', error);
+      throw new Error(`Failed to fetch project: ${error.message}`);
+    }
+
+    // Fetch related products
+    let products: import('@/lib/supabase/types').Product[] = [];
+    const projectData = data as Project;
+    if (projectData.product_ids && projectData.product_ids.length > 0) {
+      try {
+        products = await productService.getByIds(projectData.product_ids);
+      } catch (error) {
+        console.error('[ProjectService] Error fetching related products:', error);
+        // Continue without products rather than failing
+      }
+    }
+
+    const projectWithProducts: ProjectWithProducts = {
+      ...projectData,
+      products,
+    };
+
+    memoryCache.set(cacheKey, projectWithProducts, CACHE_TIMES.PROJECTS);
+    return projectWithProducts;
+  }
+
+  /**
+   * Get featured projects
+   */
+  async getFeatured(): Promise<Project[]> {
+    return this.getAll({ featured: true });
+  }
+
+  /**
+   * Get projects by year
+   */
+  async getByYear(year: number): Promise<Project[]> {
+    return this.getAll({ year });
+  }
+
+  /**
+   * Get project by ID
+   */
+  async getById(id: string): Promise<Project | null> {
+    const cacheKey = `projects:id:${id}`;
+
+    const cached = memoryCache.get<Project>(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    const supabase = getBrowserClient();
+    const { data, error } = await supabase
+      .from(TABLE_NAMES.PROJECTS)
+      .select('*')
+      .eq('id', id)
+      .eq('published', true)
+      .single();
+
+    if (error) {
+      if (error.code === 'PGRST116') {
+        return null;
+      }
+      console.error('[ProjectService] Error fetching project by ID:', error);
+      throw new Error(`Failed to fetch project: ${error.message}`);
+    }
+
+    memoryCache.set(cacheKey, data, CACHE_TIMES.PROJECTS);
+    return data;
+  }
+
+  /**
+   * Get all project slugs for static generation
+   */
+  async getAllSlugs(): Promise<string[]> {
+    const cacheKey = 'projects:slugs:all';
+
+    const cached = memoryCache.get<string[]>(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    const supabase = getBrowserClient();
+    const { data, error } = await supabase
+      .from(TABLE_NAMES.PROJECTS)
+      .select('slug')
+      .eq('published', true);
+
+    if (error) {
+      console.error('[ProjectService] Error fetching project slugs:', error);
+      throw new Error(`Failed to fetch project slugs: ${error.message}`);
+    }
+
+    const slugs = (data as { slug: string }[]).map((item) => item.slug);
+    memoryCache.set(cacheKey, slugs, CACHE_TIMES.PROJECTS);
+    return slugs;
+  }
+
+  /**
+   * Get unique years from all projects
+   */
+  async getYears(): Promise<number[]> {
+    const cacheKey = 'projects:years';
+
+    const cached = memoryCache.get<number[]>(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    const projects = await this.getAll();
+    const years = [...new Set(projects.map((p) => p.year))].sort((a, b) => b - a);
+
+    memoryCache.set(cacheKey, years, CACHE_TIMES.PROJECTS);
+    return years;
+  }
+
+  /**
+   * Invalidate all project caches
+   */
+  invalidateCache(): void {
+    memoryCache.invalidate('projects:');
+  }
+
+  /**
+   * Invalidate specific project cache
+   */
+  invalidateProjectCache(slug: string): void {
+    memoryCache.invalidateKey(`projects:slug:${slug}`);
+  }
+}
+
+export const projectService = ProjectService.getInstance();