Configuration Guide

Configuration Overview

Litestore uses a modular configuration system that allows you to customize every aspect of your platform. Configuration files are located in the config/ directory.

Environment Variables

Required Variables

# Database
DATABASE_URL="postgresql://username:password@localhost:5432/litestore"

# Authentication
NEXTAUTH_SECRET="your-32-character-secret-key"
NEXTAUTH_URL="http://localhost:3000"

# Application
NODE_ENV="development"

Optional Variables

# AI Services
OPENAI_API_KEY="sk-your-openai-api-key"

# Email Service
SMTP_HOST="smtp.gmail.com"
SMTP_PORT="587"
SMTP_USER="your-email@gmail.com"
SMTP_PASS="your-app-password"

# Payment Processing
STRIPE_SECRET_KEY="sk_test_your-stripe-secret"
STRIPE_PUBLISHABLE_KEY="pk_test_your-stripe-public"

# File Storage
CLOUDINARY_CLOUD_NAME="your-cloudinary-cloud"
CLOUDINARY_API_KEY="your-cloudinary-key"
CLOUDINARY_API_SECRET="your-cloudinary-secret"

# Analytics
GOOGLE_ANALYTICS_ID="GA_MEASUREMENT_ID"
MIXPANEL_TOKEN="your-mixpanel-token"

# Webhooks
WEBHOOK_SECRET="your-webhook-secret-key"

Database Configuration

PostgreSQL Setup

Litestore requires PostgreSQL 13+ for full feature support:

-- Create database
CREATE DATABASE litestore;

-- Create user (optional)
CREATE USER litestore_user WITH PASSWORD 'secure-password';

-- Grant permissions
GRANT ALL PRIVILEGES ON DATABASE litestore TO litestore_user;

Prisma Configuration

Database schema is defined in prisma/schema.prisma:

// prisma/schema.prisma
generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

// Models are auto-generated
model Product {
  id          String   @id @default(cuid())
  name        String
  description String?
  price       Float
  // ... other fields
}

Database Commands

# Generate Prisma client
npx prisma generate

# Create and run migrations
npx prisma migrate dev --name init

# View database in browser
npx prisma studio

# Reset database (development only)
npx prisma migrate reset

# Seed database
npx prisma db seed

AI Configuration

OpenAI Integration

Configure AI features in config/ai.config.ts:

// config/ai.config.ts
export const aiConfig = {
  provider: "openai",
  openai: {
    apiKey: process.env.OPENAI_API_KEY,
    defaultModel: "gpt-4",
    models: {
      contentGeneration: {
        model: "gpt-4",
        temperature: 0.7,
        maxTokens: 500,
        systemPrompt: "You are a helpful product description writer..."
      },
      moderation: {
        model: "gpt-3.5-turbo",
        temperature: 0.1
      },
      analysis: {
        model: "gpt-4",
        temperature: 0.2
      }
    }
  },
  rateLimits: {
    contentGeneration: 10, // requests per minute per user
    moderation: 100,
    analysis: 50
  },
  caching: {
    enabled: true,
    ttl: 3600 // 1 hour
  }
}

AI Feature Toggles

Enable or disable AI features:

export const featureFlags = {
  ai: {
    contentGeneration: true,
    productSuggestions: true,
    moderation: true,
    sentimentAnalysis: true,
    categorySuggestions: true
  }
}

Authentication Configuration

NextAuth.js Setup

Configure authentication providers in config/auth.config.ts:

// config/auth.config.ts
import { NextAuthOptions } from "next-auth";

export const authConfig: NextAuthOptions = {
  providers: [
    // Email/Password (default)
    CredentialsProvider({
      name: "credentials",
      credentials: {
        email: { label: "Email", type: "email" },
        password: { label: "Password", type: "password" }
      },
      async authorize(credentials) {
        // Authentication logic
      }
    }),

    // Social Providers (optional)
    GoogleProvider({
      clientId: process.env.GOOGLE_CLIENT_ID!,
      clientSecret: process.env.GOOGLE_CLIENT_SECRET!
    }),

    GitHubProvider({
      clientId: process.env.GITHUB_CLIENT_ID!,
      clientSecret: process.env.GITHUB_CLIENT_SECRET!
    })
  ],

  pages: {
    signIn: "/auth/sign-in",
    signUp: "/auth/sign-up"
  },

  callbacks: {
    async jwt({ token, user }) {
      if (user) {
        token.role = user.role;
      }
      return token;
    },
    async session({ session, token }) {
      session.user.role = token.role;
      return session;
    }
  }
}

Role-Based Access Control

Configure user roles and permissions:

// config/permissions.config.ts
export const permissions = {
  admin: {
    canManageUsers: true,
    canManageProducts: true,
    canManageContent: true,
    canViewAnalytics: true,
    canManageSettings: true
  },
  creator: {
    canSubmitContent: true,
    canViewOwnAnalytics: true,
    canManageProfile: true
  },
  customer: {
    canPurchase: true,
    canLeaveReviews: true,
    canViewProducts: true
  }
}

Payment Configuration

Stripe Integration

Configure Stripe for payment processing:

// config/payment.config.ts
export const paymentConfig = {
  provider: "stripe",
  stripe: {
    secretKey: process.env.STRIPE_SECRET_KEY,
    publishableKey: process.env.STRIPE_PUBLISHABLE_KEY,
    webhookSecret: process.env.STRIPE_WEBHOOK_SECRET
  },
  currency: "USD",
  supportedPaymentMethods: [
    "card",
    "paypal",
    "bank_transfer"
  ]
}

Payment Webhooks

Handle Stripe webhooks in app/api/webhooks/stripe/route.ts:

// app/api/webhooks/stripe/route.ts
import { headers } from "next/headers";
import { NextRequest, NextResponse } from "next/server";
import Stripe from "stripe";

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);

export async function POST(request: NextRequest) {
  const body = await request.text();
  const sig = headers().get("stripe-signature")!;

  try {
    const event = stripe.webhooks.constructEvent(
      body,
      sig,
      process.env.STRIPE_WEBHOOK_SECRET!
    );

    switch (event.type) {
      case "payment_intent.succeeded":
        // Handle successful payment
        break;
      case "payment_intent.payment_failed":
        // Handle failed payment
        break;
    }

    return NextResponse.json({ received: true });
  } catch (error) {
    return NextResponse.json({ error: "Webhook error" }, { status: 400 });
  }
}

File Storage Configuration

Cloudinary Setup

Configure image and file storage:

// config/storage.config.ts
export const storageConfig = {
  provider: "cloudinary",
  cloudinary: {
    cloudName: process.env.CLOUDINARY_CLOUD_NAME!,
    apiKey: process.env.CLOUDINARY_API_KEY!,
    apiSecret: process.env.CLOUDINARY_API_SECRET!,
    uploadPreset: "litestore-uploads"
  },
  allowedFormats: ["jpg", "jpeg", "png", "webp", "gif"],
  maxFileSize: 10 * 1024 * 1024, // 10MB
  imageOptimization: {
    quality: "auto",
    format: "auto",
    width: 1200,
    height: 1200,
    crop: "limit"
  }
}

Alternative Storage Providers

AWS S3

export const storageConfig = {
  provider: "s3",
  s3: {
    accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,
    region: process.env.AWS_REGION || "us-east-1",
    bucket: process.env.AWS_S3_BUCKET!
  }
}

Vercel Blob

export const storageConfig = {
  provider: "vercel-blob",
  vercel: {
    token: process.env.BLOB_READ_WRITE_TOKEN!
  }
}

Email Configuration

SMTP Setup

Configure email delivery:

// config/email.config.ts
export const emailConfig = {
  provider: "smtp",
  smtp: {
    host: process.env.SMTP_HOST || "smtp.gmail.com",
    port: parseInt(process.env.SMTP_PORT || "587"),
    secure: false,
    auth: {
      user: process.env.SMTP_USER!,
      pass: process.env.SMTP_PASS!
    }
  },
  from: {
    name: "Litestore",
    email: "noreply@yourdomain.com"
  },
  templates: {
    welcome: "welcome-email-template",
    orderConfirmation: "order-confirmation-template",
    creatorApproval: "creator-approval-template"
  }
}

Email Templates

Create email templates in templates/email/:

// templates/email/welcome-email.tsx
import { Html } from "@react-email/html";

export function WelcomeEmail({ userName }: { userName: string }) {
  return (
    <Html>
      <h1>Welcome to Litestore, {userName}!</h1>
      <p>Thank you for joining our community...</p>
    </Html>
  );
}

Analytics Configuration

Application Analytics

Configure analytics tracking:

// config/analytics.config.ts
export const analyticsConfig = {
  providers: [
    {
      name: "google-analytics",
      trackingId: process.env.GOOGLE_ANALYTICS_ID
    },
    {
      name: "mixpanel",
      token: process.env.MIXPANEL_TOKEN
    }
  ],
  events: {
    productView: "Product Viewed",
    purchase: "Purchase Completed",
    contentSubmission: "Content Submitted",
    creatorSignup: "Creator Registered"
  },
  privacy: {
    anonymizeIp: true,
    respectDoNotTrack: true,
    cookieConsent: true
  }
}

Business Intelligence

Configure business analytics:

// config/bi.config.ts
export const biConfig = {
  metrics: {
    revenue: {
      enabled: true,
      aggregation: "daily"
    },
    conversion: {
      enabled: true,
      attribution: "last-touch"
    },
    creatorPerformance: {
      enabled: true,
      metrics: ["views", "clicks", "conversions", "commission"]
    },
    contentAnalytics: {
      enabled: true,
      trackEngagement: true,
      sentimentAnalysis: true
    }
  },
  dashboards: {
    admin: ["revenue", "products", "creators", "content"],
    creator: ["performance", "earnings", "content"],
    customer: ["orders", "reviews"]
  }
}

Webhook Configuration

Webhook Endpoints

Configure webhook destinations:

// config/webhook.config.ts
export const webhookConfig = {
  endpoints: [
    {
      url: process.env.WEBHOOK_URL!,
      secret: process.env.WEBHOOK_SECRET!,
      events: [
        "content.submitted",
        "content.approved",
        "review.created",
        "product.purchased",
        "commission.earned",
        "user.registered"
      ],
      retryPolicy: {
        maxAttempts: 5,
        backoffMultiplier: 2,
        initialDelay: 1000
      }
    }
  ],
  security: {
    signatureAlgorithm: "sha256",
    signatureHeader: "X-Litestore-Signature",
    timestampTolerance: 300000 // 5 minutes
  }
}

Webhook Event Types

Available webhook events:

export const webhookEvents = {
  // Content events
  "content.submitted": "Creator content submitted",
  "content.approved": "Content approved for publication",
  "content.rejected": "Content rejected",

  // Commerce events
  "product.purchased": "Product purchase completed",
  "review.created": "New product review submitted",

  // Creator events
  "creator.registered": "New creator account created",
  "commission.earned": "Commission earned by creator",

  // User events
  "user.registered": "New user account created",
  "user.login": "User logged in"
} as const;

Performance Configuration

Caching Strategy

Configure caching for better performance:

// config/cache.config.ts
export const cacheConfig = {
  provider: "redis",
  redis: {
    url: process.env.REDIS_URL
  },
  ttl: {
    products: 3600,      // 1 hour
    categories: 7200,    // 2 hours
    content: 1800,       // 30 minutes
    analytics: 300       // 5 minutes
  },
  invalidation: {
    onProductUpdate: ["products", "categories"],
    onContentPublish: ["content", "feed"]
  }
}

CDN Configuration

Set up content delivery network:

// config/cdn.config.ts
export const cdnConfig = {
  provider: "cloudflare",
  cloudflare: {
    zoneId: process.env.CLOUDFLARE_ZONE_ID,
    apiToken: process.env.CLOUDFLARE_API_TOKEN
  },
  rules: [
    {
      pattern: "/api/*",
      cache: false
    },
    {
      pattern: "/images/*",
      cache: true,
      ttl: 31536000 // 1 year
    },
    {
      pattern: "/_next/static/*",
      cache: true,
      ttl: 31536000
    }
  ]
}

Security Configuration

CORS Settings

Configure cross-origin resource sharing:

// config/security.config.ts
export const securityConfig = {
  cors: {
    origins: [
      "http://localhost:3000",
      "https://yourdomain.com"
    ],
    methods: ["GET", "POST", "PUT", "DELETE"],
    headers: ["Content-Type", "Authorization"],
    credentials: true
  },
  rateLimiting: {
    windowMs: 15 * 60 * 1000, // 15 minutes
    max: 100, // limit each IP to 100 requests per windowMs
    message: "Too many requests from this IP, please try again later."
  },
  helmet: {
    contentSecurityPolicy: {
      directives: {
        defaultSrc: ["'self'"],
        styleSrc: ["'self'", "'unsafe-inline'"],
        scriptSrc: ["'self'"],
        imgSrc: ["'self'", "data:", "https:"]
      }
    }
  }
}

API Security

Configure API security measures:

export const apiSecurity = {
  authentication: {
    required: true,
    methods: ["bearer", "api-key"],
    rateLimit: 1000 // requests per hour
  },
  validation: {
    enabled: true,
    sanitizeInput: true,
    validateOutput: true
  },
  monitoring: {
    logRequests: true,
    alertOnAnomalies: true,
    trackPerformance: true
  }
}

Monitoring & Logging

Application Monitoring

Set up application monitoring:

// config/monitoring.config.ts
export const monitoringConfig = {
  sentry: {
    dsn: process.env.SENTRY_DSN,
    environment: process.env.NODE_ENV,
    tracesSampleRate: 1.0
  },
  logging: {
    level: process.env.LOG_LEVEL || "info",
    format: "json",
    destinations: ["console", "file"],
    file: {
      path: "./logs/app.log",
      maxSize: "10m",
      maxFiles: 5
    }
  },
  metrics: {
    enabled: true,
    provider: "prometheus",
    collectDefaultMetrics: true,
    customMetrics: [
      "http_requests_total",
      "response_time_seconds",
      "error_rate"
    ]
  }
}

Configuration Validation

Litestore validates all configuration on startup. Check the console for any configuration errors during development.

Environment-Specific Configuration

Development vs Production

Use different configurations for different environments:

// config/index.ts
import { developmentConfig } from "./development";
import { productionConfig } from "./production";

export const config = process.env.NODE_ENV === "production"
  ? productionConfig
  : developmentConfig;

Feature Flags

Enable/disable features based on environment:

// config/features.config.ts
export const featureFlags = {
  ai: {
    contentGeneration: process.env.NODE_ENV === "production",
    moderation: true,
    analysis: process.env.NODE_ENV === "production"
  },
  social: {
    creatorSubmissions: true,
    reviews: true,
    communities: process.env.NODE_ENV === "production"
  },
  commerce: {
    payments: true,
    shipping: process.env.NODE_ENV === "production",
    taxes: true
  }
}

Need Help?

Configuration can be complex. Check our troubleshooting guide for common configuration issues, or join our Discord community for help.

Configuration Guide

On this page