┌──────────────────┐
│  Discovery Jobs  │  → Trending topics, categories, creator refresh
└────────┬─────────┘
         │
         ▼
┌──────────────────┐
│   Evaluation     │  → Quality scoring, duplicate detection
└────────┬─────────┘
         │
         ▼
┌──────────────────┐
│   Aggregation    │  → Data enrichment, composite scoring
└──────────────────┘

// Example: Adding a discovery job
await queueConfig.addJob(
  'creator-discovery',
  JobType.DISCOVER_TRENDING,
  {
    platform: 'tiktok',
    topic: 'tech reviews',
    mode: 'comprehensive'
  },
  JobPriority.HIGH
);

// Evaluation outcome actions
if (evaluation.recommendation === 'add') {
  // Add to database and queue for aggregation
  await addCreatorToDatabase(creatorData, evaluation);
} else if (evaluation.recommendation === 'monitor') {
  // Add to monitoring list for future consideration
  await addToMonitoringList(creatorData, evaluation);
} else {
  // Reject with reasons logged
}

const aggregatedData = await aggregationEngine.aggregateCreatorData(
  creatorId,
  { 
    analyzeContentThemes: true,
    includeHistoricalData: false 
  }
);

const trendingTopic: TrendingTopic = {
  topic: 'AI tutorials',
  platform: 'tiktok',
  volume: 150000,
  growth: 45.2,
  relatedHashtags: ['#AITips', '#TechTutorials'],
  timestamp: new Date()
};

const creators = await trendingDiscovery.searchCreatorsByTopic(
  trendingTopic,
  50  // limit
);

// Searches Instagram, TikTok, and Twitter for category
const result = await processCategoryExploration({
  category: 'sustainable living',
  limit: 20
});

const refreshResult = await processCreatorRefresh({
  creatorId: 'abc123',
  username: '@techreviewer',
  platform: 'tiktok'
});

console.log(`New score: ${refreshResult.newScore}`);

import { DiscoveryPipeline } from './lib/discovery/discovery-pipeline';
import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();
const pipeline = new DiscoveryPipeline(prisma);

await pipeline.start();
console.log('Pipeline is running');

const status = await pipeline.getStatus();

console.log(`Running: ${status.isRunning}`);
console.log('Queue Metrics:', status.queues);
console.log('Scheduled Jobs:', status.scheduledJobs);

await pipeline.stop();
// Gracefully shuts down all queues and workers

const duplicateCheck = await duplicateDetector.checkDuplicate(creator);

if (!duplicateCheck.isDuplicate) {
  // Safe to add to evaluation queue
  await queueConfig.addJob('creator-evaluation', ...);
}

const report = await pipeline.generateReport(
  new Date('2026-03-01'),
  new Date('2026-03-06')
);

console.log(`Creators discovered: ${report.stats.creatorsDiscovered}`);
console.log(`Acceptance rate: ${report.trends.acceptanceRate}%`);
console.log(`Discovery rate: ${report.trends.discoveryRate}/day`);
console.log('Top sources:', report.stats.topSources);

interface DiscoveryReport {
  period: { start: Date; end: Date };
  stats: {
    creatorsDiscovered: number;
    creatorsAdded: number;
    creatorsRejected: number;
    platformBreakdown: Record<string, number>;
    topSources: Array<{ source: string; count: number }>;
    averageQualityScore: number;
  };
  trends: {
    discoveryRate: number;      // creators per day
    acceptanceRate: number;     // percentage accepted
    growthRate: number;         // vs previous period
  };
}

// In queue setup
this.queueConfig.createWorker(
  'creator-discovery',
  this.processDiscoveryJob.bind(this),
  { concurrency: 10 }  // Increase for more parallelism
);

enum JobPriority {
  LOW = 1,
  NORMAL = 5,
  HIGH = 10,
  CRITICAL = 20
}

// High priority for trending topics
await queueConfig.addJob(
  'creator-discovery',
  JobType.DISCOVER_TRENDING,
  data,
  JobPriority.HIGH
);

// Configure in scheduler
await scheduler.initialize();
scheduler.start();

// Schedule daily trending discovery
scheduler.scheduleRecurring(
  'daily-trending',
  '0 2 * * *',  // 2 AM daily
  { type: JobType.DISCOVER_TRENDING }
);

// Process in batches of 50
for (let i = 0; i < creators.length; i += 50) {
  const batch = creators.slice(i, i + 50);
  await Promise.all(
    batch.map(creator => 
      queueConfig.addJob('creator-evaluation', ...)
    )
  );
}

const metrics = await queueConfig.getQueueMetrics('creator-discovery');

console.log('Waiting:', metrics.waiting);
console.log('Active:', metrics.active);
console.log('Completed:', metrics.completed);
console.log('Failed:', metrics.failed);

try {
  const evaluation = await this.evaluator.evaluateCreator(creatorData);
} catch (error) {
  logger.error(`Failed to evaluate creator ${creatorData.identifier}`, error);
  // Job will be retried based on queue configuration
  throw error;
}

const jobOptions = {
  attempts: 3,
  backoff: {
    type: 'exponential',
    delay: 2000
  }
};

model CreatorProfile {
  id                String   @id @default(uuid())
  platform          String
  username          String
  followerCount     Int
  engagementRate    Float
  profileData       Json     // Includes discoverySource, evaluationScore
  createdAt         DateTime @default(now())
}