create-nextjs-stack 0.1.0

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

@@ -0,0 +1,38 @@
+import { getServerClient } from "@/lib/supabase/server";
+
+export class ProjectService {
+  private static table = "projects";
+
+  static async getAll() {
+    const supabase = await getServerClient();
+    const { data, error } = await supabase
+      .from(this.table)
+      .select("*, clients(name, logo_url)")
+      .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("*, clients(name, logo_url)")
+      .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/users.service.ts

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

package/templates/web/src/lib/supabase/client.ts

@@ -0,0 +1,42 @@
+import { createClient } from '@supabase/supabase-js';
+import { createBrowserClient } from '@supabase/ssr';
+import type { Database } from './types';
+
+/**
+ * Get Supabase client for server-side operations
+ * Uses SERVICE_ROLE_KEY for full database access
+ */
+export function getServerClient() {
+  const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL;
+  const supabaseKey = process.env.SUPABASE_SERVICE_ROLE_KEY;
+
+  if (!supabaseUrl || !supabaseKey) {
+    throw new Error(
+      'Missing Supabase credentials. Please check NEXT_PUBLIC_SUPABASE_URL and SUPABASE_SERVICE_ROLE_KEY in .env'
+    );
+  }
+
+  return createClient<Database>(supabaseUrl, supabaseKey, {
+    auth: {
+      persistSession: false,
+      autoRefreshToken: false,
+    },
+  });
+}
+
+/**
+ * Get Supabase client for browser-side operations
+ * Uses createBrowserClient from @supabase/ssr to properly handle Cookies
+ */
+export function getBrowserClient() {
+  const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL;
+  const supabaseKey = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;
+
+  if (!supabaseUrl || !supabaseKey) {
+    throw new Error(
+      'Missing Supabase credentials. Please check NEXT_PUBLIC_SUPABASE_URL and NEXT_PUBLIC_SUPABASE_ANON_KEY in .env'
+    );
+  }
+
+  return createBrowserClient<Database>(supabaseUrl, supabaseKey);
+}

package/templates/web/src/lib/supabase/constants.ts

@@ -0,0 +1,25 @@
+export const TABLE_NAMES = {
+  CATEGORIES: 'categories',
+  PRODUCTS: 'products',
+  CLIENTS: 'clients',
+  PROJECTS: 'projects',
+} as const;
+
+export const CACHE_TIMES = {
+  CATEGORIES: 3600,    // 1 hour
+  PRODUCTS: 1800,      // 30 minutes
+  CLIENTS: 3600,       // 1 hour
+  PROJECTS: 1800,      // 30 minutes
+} as const;
+
+export const CACHE_TAGS = {
+  CATEGORIES: 'categories',
+  PRODUCTS: 'products',
+  CLIENTS: 'clients',
+  PROJECTS: 'projects',
+} as const;
+
+export const RATE_LIMITS = {
+  REQUESTS_PER_MINUTE: 60,
+  REQUESTS_PER_HOUR: 1000,
+} as const;

package/templates/web/src/lib/supabase/server.ts

@@ -0,0 +1,29 @@
+import { createServerClient } from "@supabase/ssr";
+import { cookies } from "next/headers";
+
+export async function getServerClient() {
+  const cookieStore = await cookies();
+
+  return createServerClient(
+    process.env.NEXT_PUBLIC_SUPABASE_URL!,
+    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
+    {
+      cookies: {
+        getAll() {
+          return cookieStore.getAll();
+        },
+        setAll(cookiesToSet) {
+          try {
+            cookiesToSet.forEach(({ name, value, options }) =>
+              cookieStore.set(name, value, options)
+            );
+          } catch {
+            // The `setAll` method was called from a Server Component.
+            // This can be ignored if you have middleware refreshing
+            // user sessions.
+          }
+        },
+      },
+    }
+  );
+}

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

@@ -0,0 +1,112 @@
+// Database Row Types
+export interface Category {
+  id: string;
+  title: string;
+  slug: string;
+  description: string | null;
+  parent_id: string | null;
+  image_url: string | null;
+  published: boolean;
+  featured: boolean;
+  meta_description: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface Product {
+  id: string;
+  title: string;
+  slug: string;
+  short_description: string | null;
+  description: string | null;
+  category_id: string;
+  featured_image_url: string | null;
+  gallery_images: string[];
+  width: number | null;
+  height: number | null;
+  thickness: number | null;
+  material: string | null;
+  surface_finish: string | null;
+  fire_rating: string | null;
+  weight_per_sqm: number | null;
+  available_colors: string | null;
+  installation_method: string | null;
+  certifications: string | null;
+  additional_features: string | null;
+  meta_description: string | null;
+  published: boolean;
+  featured: boolean;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface Client {
+  id: string;
+  name: string;
+  website: string | null;
+  logo_url: string | null;
+  sort_order: number;
+  published: boolean;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface Project {
+  id: string;
+  title: string;
+  slug: string;
+  short_description: string | null;
+  description: string | null;
+  location: string | null;
+  year: number;
+  client_name: string | null;
+  featured_image_url: string | null;
+  gallery_images: string[];
+  product_ids: string[];
+  meta_description: string | null;
+  published: boolean;
+  featured: boolean;
+  created_at: string;
+  updated_at: string;
+}
+
+// Extended Types with Relations
+export interface CategoryWithChildren extends Category {
+  children?: CategoryWithChildren[];
+}
+
+export interface ProductWithCategory extends Product {
+  category: Category | null;
+}
+
+export interface ProjectWithProducts extends Project {
+  products: Product[];
+}
+
+// Database Type (for Supabase client)
+export interface Database {
+  public: {
+    Tables: {
+      categories: {
+        Row: Category;
+        Insert: Omit<Category, 'id' | 'created_at' | 'updated_at'>;
+        Update: Partial<Omit<Category, 'id' | 'created_at' | 'updated_at'>>;
+      };
+      products: {
+        Row: Product;
+        Insert: Omit<Product, 'id' | 'created_at' | 'updated_at'>;
+        Update: Partial<Omit<Product, 'id' | 'created_at' | 'updated_at'>>;
+      };
+      clients: {
+        Row: Client;
+        Insert: Omit<Client, 'id' | 'created_at' | 'updated_at'>;
+        Update: Partial<Omit<Client, 'id' | 'created_at' | 'updated_at'>>;
+      };
+      projects: {
+        Row: Project;
+        Insert: Omit<Project, 'id' | 'created_at' | 'updated_at'>;
+        Update: Partial<Omit<Project, 'id' | 'created_at' | 'updated_at'>>;
+      };
+    };
+  };
+}

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

@@ -0,0 +1,98 @@
+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

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

package/templates/web/src/store/actions/index.ts

@@ -0,0 +1,2 @@
+// Export actions here
+// export * from './exampleActions';

package/templates/web/src/store/index.ts

@@ -0,0 +1,13 @@
+import { createStore, applyMiddleware } from 'redux';
+import { thunk } from 'redux-thunk';
+import logger from 'redux-logger';
+import rootReducer from './reducers';
+
+const middleware = [thunk, logger];
+
+const store = createStore(
+  rootReducer,
+  applyMiddleware(...middleware)
+);
+
+export default store;

package/templates/web/src/store/reducers/index.ts

@@ -0,0 +1,13 @@
+import { combineReducers } from 'redux';
+// Import your reducers here
+// import exampleReducer from './exampleReducer';
+
+const rootReducer = combineReducers({
+  // example: exampleReducer,
+  // Add a placeholder to prevent error if no reducers yet
+  _placeholder: (state = {}) => state
+});
+
+export type RootState = ReturnType<typeof rootReducer>;
+
+export default rootReducer;

package/templates/web/src/store/types/index.ts

@@ -0,0 +1,2 @@
+// Define global types for specific actions if needed
+// export const EXAMPLE_ACTION = 'EXAMPLE_ACTION';

package/templates/web/tsconfig.json

@@ -0,0 +1,41 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}