reputation-processor.ts

/**
 * Reputation Update Processor
 *
 * Handles reputation score calculations and updates.
 * Aggregates ratings and maintains user reputation history.
 */

import { ReputationUpdatePayload, JobResult } from '../types';
import { createLogger } from '../../logger';

/**
 * Process reputation update job
 *
 * @param payload - Reputation update data
 * @returns Job result with updated reputation score
 * @throws Error if validation fails
 */
export async function processReputationUpdate(
  payload: ReputationUpdatePayload,
): Promise<JobResult> {
  const log = createLogger({
    processor: 'reputation',
    ...(payload.correlationId && { correlationId: payload.correlationId }),
    ...(payload.requestId && { requestId: payload.requestId }),
  });

  // Validate user ID
  if (!payload.userId || payload.userId.length < 5) {
    log.warn('Reputation update rejected: invalid userId');
    throw new Error('Invalid user ID');
  }

  // Validate rating range
  if (payload.rating < 1 || payload.rating > 5) {
    log.warn('Reputation update rejected: rating out of range', { rating: payload.rating });
    throw new Error('Rating must be between 1 and 5');
  }

  // Validate contract ID
  if (!payload.contractId) {
    log.warn('Reputation update rejected: missing contractId');
    throw new Error('Contract ID is required');
  }

  log.info('Processing reputation update', { rating: payload.rating });

  // Calculate new reputation score
  const newScore = await calculateReputationScore(payload);

  // Store reputation update (simulate database operation)
  await storeReputationUpdate(payload, newScore, log);

  log.info('Reputation update stored', { newScore });

  return {
    success: true,
    message: `Reputation updated for user ${payload.userId}`,
    data: {
      userId: payload.userId,
      newScore,
      rating: payload.rating,
      contractId: payload.contractId,
    },
  };
}

/**
 * Calculate new reputation score based on rating.
 * In production, this would aggregate historical ratings.
 */
async function calculateReputationScore(
  payload: ReputationUpdatePayload,
): Promise<number> {
  await new Promise((resolve) => setTimeout(resolve, 200));
  return Math.round((payload.rating / 5) * 100);
}

/**
 * Store reputation update in database
 */
async function storeReputationUpdate(
  payload: ReputationUpdatePayload,
  score: number,
  log: ReturnType<typeof createLogger>,
): Promise<void> {
  await new Promise((resolve) => setTimeout(resolve, 100));
  // userId is kept in structured field, not interpolated into the message string
  log.debug('Reputation record persisted', { score });
}