Troubleshooting Guide

npx litestore diagnose

# Use Node.js 18+ or add legacy OpenSSL provider
export NODE_OPTIONS="--openssl-legacy-provider"
npm run build

# Clear npm cache
npm cache clean --force

# Delete node_modules and reinstall
rm -rf node_modules package-lock.json
npm install

# Regenerate Prisma client
npx prisma generate

# Clear Next.js cache
rm -rf .next

# Check if PostgreSQL is running
brew services list | grep postgresql  # macOS
sudo systemctl status postgresql      # Linux

# Test connection
psql postgresql://username:password@localhost:5432/litestore

# Reset database (development only)
npx prisma migrate reset

# Check if .env.local exists
ls -la .env.local

# Verify DATABASE_URL format
echo $DATABASE_URL

# Restart development server
npm run dev

# Check migration status
npx prisma migrate status

# Resolve failed migration
npx prisma migrate resolve --applied 20231201120000_migration_name

# Reset and retry (development only)
npx prisma migrate reset

// Check NextAuth configuration
export const authOptions = {
  providers: [
    CredentialsProvider({
      async authorize(credentials) {
        // Verify user exists and password is correct
        const user = await prisma.user.findUnique({
          where: { email: credentials.email }
        });

        if (user && await bcrypt.compare(credentials.password, user.password)) {
          return user;
        }
        return null;
      }
    })
  ]
}

# Check NEXTAUTH_SECRET
echo $NEXTAUTH_SECRET  # Should be 32+ characters

# Clear browser cookies
# Restart development server

# Check API key
echo $OPENAI_API_KEY  # Should start with 'sk-'

# Verify API key permissions
curl -H "Authorization: Bearer $OPENAI_API_KEY" \
     https://api.openai.com/v1/models

// Implement retry logic
async function generateWithRetry(content: string, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await generateContent(content);
    } catch (error) {
      if (error.status === 429) {
        await new Promise(resolve => setTimeout(resolve, 1000 * (i + 1)));
        continue;
      }
      throw error;
    }
  }
}

// Check Cloudinary configuration
console.log({
  cloudName: process.env.CLOUDINARY_CLOUD_NAME,
  apiKey: process.env.CLOUDINARY_API_KEY,
  apiSecret: process.env.CLOUDINARY_API_SECRET?.slice(0, 4) + '...'
});

// Verify upload preset exists
// Check file size limits

// Verify webhook secret
const endpointSecret = process.env.STRIPE_WEBHOOK_SECRET;

// Ensure raw body is used
export const config = {
  api: {
    bodyParser: false,
  },
};

-- Add missing indexes
CREATE INDEX idx_products_category ON products(category_id);
CREATE INDEX idx_content_creator ON creator_content(creator_id);

// next.config.js
module.exports = {
  images: {
    formats: ['image/webp', 'image/avif'],
    deviceSizes: [640, 750, 828, 1080, 1200, 1920, 2048, 3840],
  }
}

// Implement caching
import { unstable_cache } from 'next/cache';

export const getProducts = unstable_cache(
  async () => {
    return prisma.product.findMany();
  },
  ['products'],
  { revalidate: 3600 }
);

// Optimize Prisma queries
const products = await prisma.product.findMany({
  select: { // Only select needed fields
    id: true,
    name: true,
    price: true
  },
  take: 20 // Limit results
});

-- Identify slow queries
SELECT query, total_time, calls, mean_time
FROM pg_stat_statements
ORDER BY mean_time DESC
LIMIT 10;

// lib/db.ts
import { PrismaClient } from '@prisma/client'

const globalForPrisma = globalThis as unknown as {
  prisma: PrismaClient | undefined
}

export const prisma = globalForPrisma.prisma ?? new PrismaClient({
  log: ['query'],
  datasources: {
    db: {
      url: process.env.DATABASE_URL,
    },
  },
})

if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = prisma

// Adjust moderation settings
const moderationConfig = {
  sensitivity: 'medium', // 'low', 'medium', 'high'
  categories: {
    spam: true,
    hate: true,
    adult: true,
    violence: false
  },
  customRules: [
    // Add custom moderation rules
  ]
}

// Verify commission rules
const rules = await prisma.commissionRule.findMany({
  where: { creatorId: creator.id }
});

// Debug calculation
const commission = calculateCommission({
  amount: order.total,
  rules: rules,
  creator: creator
});

// Use useEffect for client-only content
useEffect(() => {
  setClientOnlyData(fetchData());
}, []);

// Or use dynamic imports
const ClientComponent = dynamic(() => import('./ClientComponent'), {
  ssr: false
});

// Check Tailwind configuration
module.exports = {
  content: [
    './pages/**/*.{js,ts,jsx,tsx,mdx}',
    './components/**/*.{js,ts,jsx,tsx,mdx}',
    './app/**/*.{js,ts,jsx,tsx,mdx}',
  ],
  theme: {
    extend: {},
  },
  plugins: [],
}

// next.config.js
module.exports = {
  async headers() {
    return [
      {
        source: '/api/:path*',
        headers: [
          { key: 'Access-Control-Allow-Origin', value: '*' },
          { key: 'Access-Control-Allow-Methods', value: 'GET,POST,PUT,DELETE' },
          { key: 'Access-Control-Allow-Headers', value: 'Content-Type,Authorization' },
        ],
      },
    ]
  },
}

// Implement client-side rate limiting
import { RateLimiter } from 'limiter';

const limiter = new RateLimiter({ tokensPerInterval: 10, interval: 'minute' });

async function apiCall() {
  const remainingRequests = await limiter.removeTokens(1);
  if (remainingRequests < 0) {
    throw new Error('Rate limit exceeded');
  }
  return fetch('/api/endpoint');
}

# Clear build cache
rm -rf .next node_modules/.cache

# Check package.json
npm ls --depth=0

# Reinstall dependencies
npm ci

# Check deployment platform environment variables
# Ensure variables are prefixed correctly
# Restart application

# Check migration status
npx prisma migrate status

# Mark migration as applied
npx prisma migrate resolve --applied migration_name

# Create new migration
npx prisma migrate dev --name new_migration

// lib/logger.ts
import pino from 'pino';

export const logger = pino({
  level: process.env.LOG_LEVEL || 'info',
  transport: {
    target: 'pino-pretty',
    options: {
      colorize: true
    }
  }
});

// Usage
logger.info({ userId, action }, 'User performed action');
logger.error({ error, context }, 'Operation failed');

// pages/_app.tsx
import { useEffect } from 'react';
import { useRouter } from 'next/router';

export default function App({ Component, pageProps }) {
  const router = useRouter();

  useEffect(() => {
    const handleRouteChange = (url) => {
      // Track page views
      console.log('Page view:', url);
    };

    router.events.on('routeChangeComplete', handleRouteChange);
    return () => {
      router.events.off('routeChangeComplete', handleRouteChange);
    };
  }, [router.events]);

  return <Component {...pageProps} />;
}

// lib/db.ts
import { PrismaClient } from '@prisma/client'

const prisma = new PrismaClient({
  log: [
    { level: 'query', emit: 'event' },
    { level: 'info', emit: 'stdout' },
    { level: 'warn', emit: 'stdout' },
    { level: 'error', emit: 'stdout' },
  ],
})

prisma.$on('query', (e) => {
  console.log('Query: ' + e.query)
  console.log('Duration: ' + e.duration + 'ms')
})

# Versions
node --version          # Should be 18.17.0+
npm --version          # Latest stable
git --version          # Any recent version

# Operating System
uname -a               # Linux/macOS
# or
systeminfo | findstr /B /C:"OS"  # Windows

# Environment variables (mask sensitive data)
echo "NODE_ENV: $NODE_ENV"
echo "NEXTAUTH_URL: $NEXTAUTH_URL"
echo "DATABASE_URL: ${DATABASE_URL:0:20}..."  # First 20 chars only

# Check if required files exist
ls -la .env.local
ls -la prisma/schema.prisma

# Migration status
npx prisma migrate status

# Database connectivity
npx prisma db push --preview-feature

# Recent migrations
ls -la prisma/migrations/

# Development logs
tail -n 50 .next/development.log 2>/dev/null || echo "No dev logs"

# Production logs (if applicable)
tail -n 50 logs/app.log 2>/dev/null || echo "No app logs"

# Build logs
npm run build 2>&1 | tail -n 20

# Dependencies
npm ls --depth=0 | head -20

# Check for conflicting versions
npm ls next react @prisma/client

// Run in browser console on the affected page
console.log({
  userAgent: navigator.userAgent,
  url: window.location.href,
  viewport: {
    width: window.innerWidth,
    height: window.innerHeight
  },
  cookiesEnabled: navigator.cookieEnabled,
  localStorage: Object.keys(localStorage).length,
  errors: window.errors || [] // If you have error tracking
});

## Description
Brief description of the issue and its impact

## Steps to Reproduce
1. Go to '...'
2. Click on '...'
3. Scroll to '...'
4. See error

## Expected Behavior
What should happen when following the steps above

## Actual Behavior
What actually happens (include screenshots if applicable)

## Environment
- Litestore version: [run `npm list litestore` or check package.json]
- Node.js version: [run `node --version`]
- Browser: [e.g., Chrome 120, Safari 17]
- OS: [e.g., macOS 14.0, Windows 11, Ubuntu 22.04]
- Database: [PostgreSQL version]

## Additional Context
- Error messages from console/terminal
- Screenshots of the issue
- Any recent changes that might have caused this
- Diagnostic information (from above)
- Reproduction repository (if possible)