Inngest Background Jobs

import { Inngest } from 'inngest';

// 🎯 Cliente Inngest - ponto central para todos os events
export const inngest = new Inngest({ 
  id: 'my-saas-app',
  name: 'My SaaS Application',
  
  // 🔒 Event key para segurança (production)
  eventKey: process.env.INNGEST_EVENT_KEY,
  
  // 🎨 Schema de events para type-safety
  schemas: {
    // Definiremos events específicos aqui
  }
});

# Inngest Configuration
INNGEST_EVENT_KEY=your_event_key_here
INNGEST_SIGNING_KEY=your_signing_key_here

# Para development local
INNGEST_DEV=true

import { serve } from 'inngest/next';
import { inngest } from '@/inngest/client';

// 🎯 Import todas as functions aqui
import { 
  sendWelcomeEmail,
  processStripeWebhook,
  generateMonthlyReport 
} from '@/inngest/functions';

// 🚀 Serve Inngest functions via Next.js API route
export const { GET, POST, PUT } = serve({
  client: inngest,
  functions: [
    sendWelcomeEmail,
    processStripeWebhook,
    generateMonthlyReport,
    // Adicione novas functions aqui
  ],
  
  // 🔒 Configurações de segurança
  signingKey: process.env.INNGEST_SIGNING_KEY,
  
  // 🛠️ Development mode
  isDev: process.env.NODE_ENV === 'development',
});

import { inngest } from '@/inngest/client';
import { NextRequest, NextResponse } from 'next/server';

export async function POST(request: NextRequest) {
  try {
    const { email, firstName, lastName } = await request.json();
    
    // 1️⃣ Criar usuário no banco
    const user = await prisma.user.create({
      data: { email, firstName, lastName }
    });
    
    // 2️⃣ Disparar event para background jobs
    await inngest.send({
      name: 'user/signup.completed',
      data: {
        user: {
          id: user.id,
          email: user.email,
          firstName: user.firstName,
          lastName: user.lastName
        },
        metadata: {
          source: 'web_signup',
          timestamp: new Date().toISOString(),
          userAgent: request.headers.get('user-agent')
        }
      }
    });
    
    return NextResponse.json({ 
      success: true, 
      userId: user.id 
    });
    
  } catch (error) {
    console.error('Signup error:', error);
    return NextResponse.json(
      { error: 'Signup failed' }, 
      { status: 500 }
    );
  }
}

'use server';

import { inngest } from '@/inngest/client';
import { auth } from '@clerk/nextjs/server';

export async function updateUserProfile(formData: FormData) {
  const { userId } = await auth();
  
  if (!userId) {
    throw new Error('Unauthorized');
  }
  
  // Update user profile...
  const updatedUser = await updateUser(userId, formData);
  
  // 🎯 Trigger background job para sync com CRM
  await inngest.send({
    name: 'user/profile.updated',
    data: {
      userId,
      changes: updatedUser,
      updatedAt: new Date().toISOString()
    }
  });
  
  return { success: true };
}

import { inngest } from '@/inngest/client';
import { headers } from 'next/headers';
import Stripe from 'stripe';

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

export async function POST(request: Request) {
  const body = await request.text();
  const signature = headers().get('stripe-signature')!;
  
  let event: Stripe.Event;
  
  try {
    event = stripe.webhooks.constructEvent(
      body, 
      signature, 
      process.env.STRIPE_WEBHOOK_SECRET!
    );
  } catch (err) {
    return new Response(`Webhook error: ${err}`, { status: 400 });
  }
  
  // 🎯 Enviar para Inngest processar de forma robusta
  await inngest.send({
    name: 'stripe/webhook.received',
    data: {
      type: event.type,
      stripeEventId: event.id,
      payload: event.data,
      receivedAt: new Date().toISOString()
    }
  });
  
  return new Response('OK');
}

export const exampleFunction = inngest.createFunction(
  { id: 'example-function' },
  { event: 'example/event' },
  
  async ({ event, step, logger }) => {
    // 📝 Log estruturado no início
    logger.info('Function started', {
      eventId: event.id,
      userId: event.data.userId,
      timestamp: new Date().toISOString()
    });
    
    // 🔧 Log em cada step importante
    const result = await step.run('process-data', async () => {
      logger.debug('Processing data', { 
        dataSize: event.data.items.length 
      });
      
      try {
        const processed = await processData(event.data);
        
        // ✅ Log de sucesso
        logger.info('Data processed successfully', {
          itemsProcessed: processed.length,
          duration: Date.now() - startTime
        });
        
        return processed;
      } catch (error) {
        // ❌ Log de erro com contexto
        logger.error('Data processing failed', {
          error: error.message,
          stack: error.stack,
          input: event.data
        });
        
        throw error; // Re-throw para trigger retry
      }
    });
    
    // 🎯 Log final com métricas
    logger.info('Function completed', {
      success: true,
      resultCount: result.length,
      totalDuration: Date.now() - functionStartTime
    });
    
    return result;
  }
);

import { createTRPCRouter, protectedProcedure } from '@/trpc/init';
import { inngest } from '@/inngest/client';
import { z } from 'zod';

export const reportsRouter = createTRPCRouter({
  // 📊 Generate report - resposta imediata, processing em background
  generateReport: protectedProcedure
    .input(z.object({
      type: z.enum(['monthly', 'quarterly', 'annual']),
      filters: z.object({
        startDate: z.string(),
        endDate: z.string(),
        includeChurn: z.boolean().default(true)
      }).optional()
    }))
    .mutation(async ({ ctx, input }) => {
      const reportId = generateId();
      
      // 1️⃣ Criar record de report (status: pending)
      const report = await prisma.report.create({
        data: {
          id: reportId,
          type: input.type,
          status: 'pending',
          userId: ctx.auth.userId,
          filters: input.filters,
          createdAt: new Date()
        }
      });
      
      // 2️⃣ Disparar background job
      await inngest.send({
        name: 'report/generation.requested',
        data: {
          reportId,
          userId: ctx.auth.userId,
          type: input.type,
          filters: input.filters
        }
      });
      
      // 3️⃣ Resposta imediata ao cliente
      return {
        reportId,
        status: 'pending',
        message: 'Report generation started. You will be notified when ready.'
      };
    }),
    
  // 📋 Get report status
  getReportStatus: protectedProcedure
    .input(z.object({ reportId: z.string() }))
    .query(async ({ ctx, input }) => {
      const report = await prisma.report.findFirst({
        where: {
          id: input.reportId,
          userId: ctx.auth.userId
        }
      });
      
      if (!report) {
        throw new TRPCError({
          code: 'NOT_FOUND',
          message: 'Report not found'
        });
      }
      
      return {
        id: report.id,
        status: report.status,
        progress: report.progress,
        downloadUrl: report.downloadUrl,
        createdAt: report.createdAt,
        completedAt: report.completedAt
      };
    })
});

import { inngest } from '../client';

export const generateReport = inngest.createFunction(
  {
    id: 'generate-report',
    name: 'Generate Report',
    retries: { attempts: 3 },
    timeout: '15m' // Reports podem demorar
  },
  
  { event: 'report/generation.requested' },
  
  async ({ event, step, logger }) => {
    const { reportId, userId, type, filters } = event.data;
    
    // 📊 Step 1: Update status to processing
    await step.run('update-status-processing', async () => {
      return await prisma.report.update({
        where: { id: reportId },
        data: { 
          status: 'processing',
          startedAt: new Date()
        }
      });
    });
    
    // 📈 Step 2: Collect data (pode ser lento)
    const reportData = await step.run('collect-report-data', async () => {
      logger.info('Collecting data for report', { reportId, type });
      
      // Simulate complex data processing
      const data = await collectReportData(type, filters);
      
      // Update progress
      await prisma.report.update({
        where: { id: reportId },
        data: { progress: 50 }
      });
      
      return data;
    });
    
    // 📄 Step 3: Generate PDF/Excel (pode ser lento)
    const fileUrl = await step.run('generate-report-file', async () => {
      logger.info('Generating report file', { reportId });
      
      const file = await generateReportFile(reportData, type);
      
      // Update progress
      await prisma.report.update({
        where: { id: reportId },
        data: { progress: 80 }
      });
      
      return file.url;
    });
    
    // ✅ Step 4: Update status to completed
    await step.run('update-status-completed', async () => {
      return await prisma.report.update({
        where: { id: reportId },
        data: {
          status: 'completed',
          downloadUrl: fileUrl,
          completedAt: new Date(),
          progress: 100
        }
      });
    });
    
    // 📧 Step 5: Notify user via email
    await step.run('notify-user', async () => {
      const user = await prisma.user.findUnique({
        where: { id: userId }
      });
      
      return await sendEmail({
        to: user.email,
        subject: 'Your report is ready! 📊',
        template: 'report-ready',
        data: {
          reportType: type,
          downloadUrl: fileUrl,
          userName: user.firstName
        }
      });
    });
    
    return {
      success: true,
      reportId,
      downloadUrl: fileUrl
    };
  }
);

'use client';

import { useTRPC } from '@/trpc/client';
import { useMutation, useQuery } from '@tanstack/react-query';
import { useState } from 'react';

export function ReportGenerator() {
  const [reportId, setReportId] = useState<string | null>(null);
  
  const trpc = useTRPC();
  
  // 🚀 Mutation para gerar report
  const generateMutation = useMutation({
    ...trpc.reports.generateReport.mutationOptions(),
    onSuccess: (data) => {
      setReportId(data.reportId);
    }
  });
  
  // 🔄 Polling para status do report
  const { data: reportStatus } = useQuery({
    ...trpc.reports.getReportStatus.queryOptions({
      reportId: reportId!
    }),
    enabled: !!reportId,
    refetchInterval: (data) => {
      // Stop polling quando completo
      return data?.status === 'completed' ? false : 2000;
    }
  });
  
  const handleGenerate = () => {
    generateMutation.mutate({
      type: 'monthly',
      filters: {
        startDate: '2025-01-01',
        endDate: '2025-01-31'
      }
    });
  };
  
  return (
    <div className="space-y-4">
      <button 
        onClick={handleGenerate}
        disabled={generateMutation.isPending}
        className="btn btn-primary"
      >
        {generateMutation.isPending ? 'Starting...' : 'Generate Report'}
      </button>
      
      {reportStatus && (
        <div className="bg-bg-2 p-4 rounded">
          <p>Status: {reportStatus.status}</p>
          {reportStatus.progress && (
            <div className="w-full bg-bg-3 rounded-full h-2">
              <div 
                className="bg-blue-600 h-2 rounded-full" 
                style={{ width: `${reportStatus.progress}%` }}
              />
            </div>
          )}
          
          {reportStatus.status === 'completed' && (
            <a 
              href={reportStatus.downloadUrl}
              className="btn btn-success mt-2"
              download
            >
              Download Report
            </a>
          )}
        </div>
      )}
    </div>
  );
}