create-nextjs-stack 0.1.1 → 0.1.4

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

@@ -1,251 +0,0 @@
-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();

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

@@ -1,132 +0,0 @@
-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/productService.ts

@@ -1,261 +0,0 @@
-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();