create-nextjs-stack 0.1.1 → 0.1.4

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

@@ -1,234 +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 { 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();

package/templates/web/src/lib/utils/cache.ts

@@ -1,98 +0,0 @@
-interface CacheEntry<T> {
-  data: T;
-  timestamp: number;
-  ttl: number;
-}
-
-/**
- * In-memory cache with TTL (Time To Live) support
- * Provides fast access to frequently requested data
- */
-class MemoryCache {
-  private cache: Map<string, CacheEntry<unknown>> = new Map();
-
-  /**
-   * Store data in cache with TTL
-   * @param key - Cache key
-   * @param data - Data to cache
-   * @param ttl - Time to live in seconds
-   */
-  set<T>(key: string, data: T, ttl: number): void {
-    this.cache.set(key, {
-      data,
-      timestamp: Date.now(),
-      ttl,
-    });
-  }
-
-  /**
-   * Retrieve data from cache
-   * @param key - Cache key
-   * @returns Cached data or null if expired/not found
-   */
-  get<T>(key: string): T | null {
-    const entry = this.cache.get(key) as CacheEntry<T> | undefined;
-
-    if (!entry) {
-      return null;
-    }
-
-    // Check if entry has expired
-    const age = Date.now() - entry.timestamp;
-    if (age > entry.ttl * 1000) {
-      this.cache.delete(key);
-      return null;
-    }
-
-    return entry.data;
-  }
-
-  /**
-   * Check if key exists and is not expired
-   * @param key - Cache key
-   */
-  has(key: string): boolean {
-    return this.get(key) !== null;
-  }
-
-  /**
-   * Invalidate cache entries matching a pattern
-   * @param pattern - String pattern to match against keys
-   */
-  invalidate(pattern: string): void {
-    const keys = Array.from(this.cache.keys());
-    keys.forEach((key) => {
-      if (key.includes(pattern)) {
-        this.cache.delete(key);
-      }
-    });
-  }
-
-  /**
-   * Invalidate specific cache key
-   * @param key - Cache key to invalidate
-   */
-  invalidateKey(key: string): void {
-    this.cache.delete(key);
-  }
-
-  /**
-   * Clear all cache entries
-   */
-  clear(): void {
-    this.cache.clear();
-  }
-
-  /**
-   * Get cache statistics
-   */
-  getStats() {
-    return {
-      size: this.cache.size,
-      keys: Array.from(this.cache.keys()),
-    };
-  }
-}
-
-// Export singleton instance
-export const memoryCache = new MemoryCache();

package/templates/web/src/lib/utils/rate-limiter.ts

@@ -1,102 +0,0 @@
-import { RATE_LIMITS } from '@/lib/supabase/constants';
-
-interface RateLimitEntry {
-  tokens: number;
-  lastRefill: number;
-}
-
-/**
- * Token Bucket Rate Limiter
- * Implements the token bucket algorithm for rate limiting
- */
-class RateLimiter {
-  private buckets: Map<string, RateLimitEntry> = new Map();
-  private maxTokens: number;
-  private refillRate: number; // tokens per second
-
-  /**
-   * @param maxTokens - Maximum number of tokens in the bucket
-   * @param refillRate - Number of tokens added per second
-   */
-  constructor(maxTokens: number, refillRate: number) {
-    this.maxTokens = maxTokens;
-    this.refillRate = refillRate;
-  }
-
-  /**
-   * Check if request is allowed under rate limit
-   * @param key - Unique identifier for the rate limit bucket (e.g., user ID, IP, endpoint)
-   * @returns true if request is allowed, false if rate limited
-   */
-  async checkLimit(key: string): Promise<boolean> {
-    const now = Date.now();
-    let bucket = this.buckets.get(key);
-
-    // Initialize bucket if it doesn't exist
-    if (!bucket) {
-      bucket = {
-        tokens: this.maxTokens - 1,
-        lastRefill: now,
-      };
-      this.buckets.set(key, bucket);
-      return true;
-    }
-
-    // Refill tokens based on time passed
-    const timePassed = (now - bucket.lastRefill) / 1000; // in seconds
-    const tokensToAdd = timePassed * this.refillRate;
-    bucket.tokens = Math.min(this.maxTokens, bucket.tokens + tokensToAdd);
-    bucket.lastRefill = now;
-
-    // Check if we have tokens available
-    if (bucket.tokens >= 1) {
-      bucket.tokens -= 1;
-      return true;
-    }
-
-    // Rate limit exceeded
-    return false;
-  }
-
-  /**
-   * Get remaining tokens for a key
-   * @param key - Rate limit bucket key
-   */
-  getRemainingTokens(key: string): number {
-    const bucket = this.buckets.get(key);
-    if (!bucket) {
-      return this.maxTokens;
-    }
-
-    const now = Date.now();
-    const timePassed = (now - bucket.lastRefill) / 1000;
-    const tokensToAdd = timePassed * this.refillRate;
-    return Math.min(this.maxTokens, bucket.tokens + tokensToAdd);
-  }
-
-  /**
-   * Reset rate limit for a specific key
-   * @param key - Rate limit bucket key
-   */
-  reset(key: string): void {
-    this.buckets.delete(key);
-  }
-
-  /**
-   * Clear all rate limit buckets
-   */
-  clearAll(): void {
-    this.buckets.clear();
-  }
-}
-
-// Global rate limiters
-export const perMinuteLimiter = new RateLimiter(
-  RATE_LIMITS.REQUESTS_PER_MINUTE,
-  RATE_LIMITS.REQUESTS_PER_MINUTE / 60 // tokens per second
-);
-
-export const perHourLimiter = new RateLimiter(
-  RATE_LIMITS.REQUESTS_PER_HOUR,
-  RATE_LIMITS.REQUESTS_PER_HOUR / 3600 // tokens per second
-);