Merge pull request #125 from topcoder-platform/PM-5221

PM-5221: rate Data Science Challenge history

Author: jmgasper

src/ratings/developRatingEngine.js

@@ -68,6 +68,52 @@ function normalizeChallengeDimension (value) {
     .replace(/[\s-]+/g, '_')
 }
 
+/**
+ * Normalize one or more rating-context values into an array.
+ * @param {*} value scalar or array option value
+ * @returns {Array<*>} option values as an array
+ */
+function toRatingContextArray (value) {
+  if (Array.isArray(value)) {
+    return value
+  }
+
+  return value ? [value] : []
+}
+
+/**
+ * Build source challenge filters and target unified dimensions for this rating run.
+ * Defaults preserve the historical DEVELOPMENT / Challenge stream.
+ * @param {Object} [options] rerate options
+ * @param {string} [options.targetTrackName] unified stats track to update
+ * @param {string} [options.targetTypeName] unified stats type to update
+ * @param {Array<string>|string} [options.challengeTrackNames] source challenge tracks to replay
+ * @param {Array<string>|string} [options.challengeTypeNames] source challenge types to replay
+ * @returns {Object} normalized rating context
+ */
+function buildRatingContext (options = {}) {
+  const challengeTrackNames = toRatingContextArray(options.challengeTrackNames || options.challengeTrackName)
+  const challengeTypeNames = toRatingContextArray(options.challengeTypeNames || options.challengeTypeName)
+
+  return {
+    targetTrackName: String(options.targetTrackName || TRACK_NAME).trim() || TRACK_NAME,
+    targetTypeName: String(options.targetTypeName || TYPE_NAME).trim() || TYPE_NAME,
+    challengeTrackNames: (challengeTrackNames.length > 0 ? challengeTrackNames : [CHALLENGE_TRACK_NAME])
+      .map(normalizeChallengeDimension),
+    challengeTypeNames: (challengeTypeNames.length > 0 ? challengeTypeNames : CHALLENGE_TYPE_NAMES)
+      .map(normalizeChallengeDimension)
+  }
+}
+
+/**
+ * Build the human-readable label for rerate errors.
+ * @param {Object} ratingContext normalized rating context
+ * @returns {string} target track/type label
+ */
+function getRatingContextLabel (ratingContext) {
+  return `${ratingContext.targetTrackName}/${ratingContext.targetTypeName}`
+}
+
 /**
  * Add one non-empty challenge id candidate to the supplied set.
  * @param {Set<string>} candidates mutable challenge id candidate set
@@ -150,22 +196,23 @@ function historyEntryMatchesChallengeId (historyEntry, challengeId) {
 }
 
 /**
- * Resolve whether challenge metadata belongs to the Development Challenge rating stream.
- * Development CODE challenge rows are rated into the same DEVELOP / Challenge
- * stream as standard Development Challenge rows.
+ * Resolve whether challenge metadata belongs to the configured Challenge rating stream.
+ * By default, Development CODE challenge rows are rated into the same
+ * DEVELOP / Challenge stream as standard Development Challenge rows.
  * @param {Object} challenge challenge metadata record
+ * @param {Object} [ratingContext] normalized rating context
  * @returns {boolean} true when the challenge should be replayed by this engine
  */
-function isDevelopmentRatingChallenge (challenge) {
+function isDevelopmentRatingChallenge (challenge, ratingContext = buildRatingContext()) {
   if (!challenge || !challenge.track || !challenge.type) {
     return false
   }
 
   const normalizedTrackName = normalizeChallengeDimension(challenge.track.name)
   const normalizedTypeName = normalizeChallengeDimension(challenge.type.name)
-  const supportedTypeNames = CHALLENGE_TYPE_NAMES.map(normalizeChallengeDimension)
 
-  return normalizedTrackName === CHALLENGE_TRACK_NAME && supportedTypeNames.includes(normalizedTypeName)
+  return ratingContext.challengeTrackNames.includes(normalizedTrackName) &&
+    ratingContext.challengeTypeNames.includes(normalizedTypeName)
 }
 
 function isCompletedChallenge (challenge) {
@@ -246,24 +293,25 @@ function buildUserStateKey (userId) {
 }
 
 /**
- * Resolve the unified track/type UUIDs used for DEVELOPMENT / Challenge rows.
+ * Resolve the unified track/type UUIDs used for this challenge-result rating stream.
  * @param {Object} challengeClient prisma challenge client
+ * @param {Object} [ratingContext] normalized rating context
  * @returns {Promise<{trackId: string, typeId: string, trackName: string, typeName: string, dimensionLookup: Object}>} resolved unified ids
  */
-async function resolveUnifiedDimensionIds (challengeClient) {
+async function resolveUnifiedDimensionIds (challengeClient, ratingContext = buildRatingContext()) {
   const dimensionLookup = await loadChallengeDimensionLookup(challengeClient)
-  const trackId = resolveTrackIdFromLookup(dimensionLookup, TRACK_NAME)
-  const typeId = resolveTypeIdFromLookup(dimensionLookup, TYPE_NAME)
+  const trackId = resolveTrackIdFromLookup(dimensionLookup, ratingContext.targetTrackName)
+  const typeId = resolveTypeIdFromLookup(dimensionLookup, ratingContext.targetTypeName)
 
   if (!trackId || !typeId) {
-    throw new Error(`Unable to resolve unified dimension ids for ${TRACK_NAME}/${TYPE_NAME}`)
+    throw new Error(`Unable to resolve unified dimension ids for ${getRatingContextLabel(ratingContext)}`)
   }
 
   return {
     trackId,
     typeId,
-    trackName: TRACK_NAME,
-    typeName: TYPE_NAME,
+    trackName: ratingContext.targetTrackName,
+    typeName: ratingContext.targetTypeName,
     dimensionLookup
   }
 }
@@ -548,10 +596,12 @@ function isCanonicalReviewChallengeRow (row, challenge) {
  * @param {Object} [options] history filtering options
  * @param {boolean} [options.skipLegacyReviewIds=false] ignore legacy numeric review ids that are already represented by legacy subtrack history
  * @param {boolean} [options.useLegacySourceRatings=false] preserve challengeResult oldRating/newRating for legacy-backed rows
+ * @param {Object} [options.ratingContext] source and target dimension config
  * @returns {Array<Object>} ordered challenge history entries for rerating
  */
 function buildTargetHistory (reviewRows, challengeMetadataById, options = {}) {
   const historyByChallengeId = new Map()
+  const ratingContext = options.ratingContext || buildRatingContext()
 
   reviewRows.forEach((row) => {
     if (!isParticipantEligibleForRating(row)) {
@@ -575,7 +625,7 @@ function buildTargetHistory (reviewRows, challengeMetadataById, options = {}) {
       return
     }
 
-    if (!isDevelopmentRatingChallenge(challenge)) {
+    if (!isDevelopmentRatingChallenge(challenge, ratingContext)) {
       return
     }
 
@@ -942,6 +992,10 @@ async function refreshMostRecentHistoryFlag (tx, userId, dimensionIds) {
  * @param {boolean} [options.recalculateRanks=true] recompute Develop Challenge ranks after this member rerate
  * @param {boolean} [options.skipLegacyReviewIds=false] skip legacy numeric challengeResult aliases during full migration rerates
  * @param {boolean} [options.useLegacySourceRatings=false] preserve challengeResult oldRating/newRating for legacy-backed rows
+ * @param {string} [options.targetTrackName=DEVELOP] unified stats track to update
+ * @param {string} [options.targetTypeName=Challenge] unified stats type to update
+ * @param {Array<string>|string} [options.challengeTrackNames=DEVELOPMENT] source challenge tracks to replay
+ * @param {Array<string>|string} [options.challengeTypeNames=[Challenge,CODE]] source challenge types to replay
  * @returns {Promise<{challengesProcessed: number, ratingsUpdated: number}>} rerate counters
  * @throws {Error} when required review DB or dimension data is unavailable
  */
@@ -951,6 +1005,7 @@ async function rerateDevTrack (membersClient, challengeClient, reviewDbClient, u
   }
 
   const normalizedUserId = toBigIntUserId(userId)
+  const ratingContext = buildRatingContext(options)
   const reviewRows = await fetchReviewResultsForUser(reviewDbClient, normalizedUserId)
   if (reviewRows.length === 0) {
     return {
@@ -966,7 +1021,8 @@ async function rerateDevTrack (membersClient, challengeClient, reviewDbClient, u
 
   const targetHistory = buildTargetHistory(reviewRows, challengeMetadataById, {
     skipLegacyReviewIds: options.skipLegacyReviewIds === true,
-    useLegacySourceRatings: options.useLegacySourceRatings === true
+    useLegacySourceRatings: options.useLegacySourceRatings === true,
+    ratingContext
   })
   if (targetHistory.length === 0) {
     return {
@@ -975,13 +1031,14 @@ async function rerateDevTrack (membersClient, challengeClient, reviewDbClient, u
     }
   }
 
-  const dimensionIds = await resolveUnifiedDimensionIds(challengeClient)
+  const dimensionIds = await resolveUnifiedDimensionIds(challengeClient, ratingContext)
+  const ratingLabel = getRatingContextLabel(ratingContext)
 
   let startIndex = 0
   if (fromChallengeId) {
     startIndex = targetHistory.findIndex((entry) => historyEntryMatchesChallengeId(entry, fromChallengeId))
     if (startIndex < 0) {
-      throw new errors.BadRequestError(`Challenge ${fromChallengeId} is not a rated ${TRACK_NAME}/${TYPE_NAME} event for this member`)
+      throw new errors.BadRequestError(`Challenge ${fromChallengeId} is not a rated ${ratingLabel} event for this member`)
     }
   }
 

src/services/StatisticsService.js

@@ -66,6 +66,7 @@ if (!_.includes(SUPPORTED_STATS_READ_SOURCES, configuredStatsReadSource)) {
 }
 const USE_LEGACY_STATS_READS = configuredStatsReadSource === LEGACY_STATS_READ_SOURCE
 const RATING_SOURCE_DEVELOPMENT = 'DEVELOPMENT_CHALLENGE'
+const RATING_SOURCE_DATA_SCIENCE_CHALLENGE = 'DATA_SCIENCE_CHALLENGE'
 const RATING_SOURCE_MARATHON_MATCH = 'MARATHON_MATCH'
 const RERATE_MARATHON_ACTOR = 'rerate-mm-stats'
 const CHALLENGE_WINNER_PLACEMENT_TYPE = 'PLACEMENT'
@@ -435,6 +436,10 @@ function resolveChallengeRatingSource (challenge) {
     return RATING_SOURCE_DEVELOPMENT
   }
 
+  if (trackName === TRACK_NAMES.DATA_SCIENCE && typeName === TYPE_NAMES.CHALLENGE) {
+    return RATING_SOURCE_DATA_SCIENCE_CHALLENGE
+  }
+
   if (trackName === TRACK_NAMES.DATA_SCIENCE && typeName === TYPE_NAMES.MARATHON_MATCH) {
     return RATING_SOURCE_MARATHON_MATCH
   }
@@ -461,6 +466,14 @@ function buildBaseRatingJob (challenge, source) {
     }
   }
 
+  if (source === RATING_SOURCE_DATA_SCIENCE_CHALLENGE) {
+    return {
+      source,
+      trackId: TRACK_NAMES.DATA_SCIENCE,
+      typeId: TYPE_NAMES.CHALLENGE
+    }
+  }
+
   if (source === RATING_SOURCE_MARATHON_MATCH) {
     return {
       source,
@@ -635,13 +648,24 @@ async function rerateChallengeRatingJobForMember (challengeClient, reviewDbClien
     )
   }
 
-  if (job.source === RATING_SOURCE_DEVELOPMENT) {
+  if (job.source === RATING_SOURCE_DEVELOPMENT ||
+    job.source === RATING_SOURCE_DATA_SCIENCE_CHALLENGE) {
+    const rerateOptions = job.source === RATING_SOURCE_DATA_SCIENCE_CHALLENGE
+      ? {
+        targetTrackName: TRACK_NAMES.DATA_SCIENCE,
+        targetTypeName: TYPE_NAMES.CHALLENGE,
+        challengeTrackNames: [TRACK_NAMES.DATA_SCIENCE],
+        challengeTypeNames: [TYPE_NAMES.CHALLENGE]
+      }
+      : undefined
+
     return rerateDevTrack(
       prisma,
       challengeClient,
       reviewDbClient,
       userId,
-      challengeId
+      challengeId,
+      rerateOptions
     )
   }
 
@@ -4299,8 +4323,9 @@ rerateChallengeSubmitterRatings.schema = {
 }
 
 /**
- * Trigger a DEVELOPMENT / Challenge, DATA_SCIENCE / MARATHON_MATCH, or configured
- * tag- or skill-based rating path re-rating pass beginning with the supplied challenge.
+ * Trigger a DEVELOPMENT / Challenge, DATA_SCIENCE / Challenge,
+ * DATA_SCIENCE / MARATHON_MATCH, or configured tag- or skill-based rating path
+ * re-rating pass beginning with the supplied challenge.
  * The relevant review-api results are reprocessed in chronological order and
  * persisted into the existing unified rating tables for the member.
  * @param {Object} currentUser the user who performs operation
@@ -4343,6 +4368,20 @@ async function rerateMemberStats (currentUser, handle, data) {
       member.userId,
       payload.challengeId
     )
+  } else if (trackId === TRACK_NAMES.DATA_SCIENCE && typeId === TYPE_NAMES.CHALLENGE) {
+    result = await rerateDevTrack(
+      prisma,
+      challengeClient,
+      reviewDbClient,
+      member.userId,
+      payload.challengeId,
+      {
+        targetTrackName: TRACK_NAMES.DATA_SCIENCE,
+        targetTypeName: TYPE_NAMES.CHALLENGE,
+        challengeTrackNames: [TRACK_NAMES.DATA_SCIENCE],
+        challengeTypeNames: [TYPE_NAMES.CHALLENGE]
+      }
+    )
   } else if (trackId === TRACK_NAMES.DATA_SCIENCE && typeId === TYPE_NAMES.MARATHON_MATCH) {
     result = await rerateMmTrack(
       prisma,
@@ -4353,7 +4392,7 @@ async function rerateMemberStats (currentUser, handle, data) {
       payload.challengeId
     )
   } else {
-    throw new errors.BadRequestError('Only DEVELOP / Challenge and DATA_SCIENCE / MARATHON_MATCH rerates are currently supported.')
+    throw new errors.BadRequestError('Only DEVELOP / Challenge, DATA_SCIENCE / Challenge, and DATA_SCIENCE / MARATHON_MATCH rerates are currently supported.')
   }
 
   return {

test/unit/DevelopRatingEngine.test.js

@@ -422,6 +422,96 @@ function findHistoryRow (historyRows, userId, challengeId) {
 }
 
 describe('develop rating engine unit tests', () => {
+  it('rerateDevTrack should support Data Science Challenge rating dimensions', async () => {
+    const targetUserId = toBigInt(1001)
+    const opponentUserId = toBigInt(2002)
+    const challengeId = 'ds-challenge-1'
+    const eventDate = new Date('2026-06-02T05:30:04.536Z')
+    const members = createMembersClient({
+      historyRows: [],
+      statsRows: [],
+      maxRatingRows: []
+    })
+    const reviewDbClient = createReviewDbClient([
+      {
+        challengeId,
+        userId: targetUserId,
+        finalScore: 100,
+        placement: 1,
+        rated: true,
+        createdAt: new Date('2026-06-02T04:49:42.752Z')
+      },
+      {
+        challengeId,
+        userId: opponentUserId,
+        finalScore: 88.89,
+        placement: 2,
+        rated: true,
+        createdAt: new Date('2026-06-02T04:46:08.538Z')
+      }
+    ])
+    const challengeClient = createChallengeClient({
+      [challengeId]: {
+        id: challengeId,
+        endDate: eventDate,
+        track: { name: 'Data Science' },
+        type: { name: 'Challenge' }
+      }
+    })
+    const expectedParticipants = [
+      createParticipant(targetUserId, 0, 0, 0, 100),
+      createParticipant(opponentUserId, 0, 0, 0, 88.89)
+    ]
+    runQubitsRating(expectedParticipants)
+    const expectedTarget = expectedParticipants.find((participant) => participant.coderId === String(targetUserId))
+
+    const result = await rerateDevTrack(
+      members.client,
+      challengeClient,
+      reviewDbClient,
+      targetUserId,
+      challengeId,
+      {
+        targetTrackName: 'DATA_SCIENCE',
+        targetTypeName: 'Challenge',
+        challengeTrackNames: ['DATA_SCIENCE'],
+        challengeTypeNames: ['Challenge']
+      }
+    )
+
+    result.challengesProcessed.should.equal(1)
+    result.ratingsUpdated.should.equal(1)
+
+    const statsRow = members.state.statsRows.find((row) =>
+      String(row.userId) === String(targetUserId) &&
+      row.trackId === DATA_SCIENCE_TRACK_ID &&
+      row.typeId === CHALLENGE_TYPE_ID
+    )
+    should.exist(statsRow)
+    statsRow.rating.should.equal(expectedTarget.rating)
+    statsRow.volatility.should.equal(expectedTarget.volatility)
+    statsRow.challenges.should.equal(1)
+    statsRow.mostRecentEventDate.should.deep.equal(eventDate)
+
+    const historyRow = findHistoryRow(members.state.historyRows, targetUserId, challengeId)
+    should.exist(historyRow)
+    historyRow.trackId.should.equal(DATA_SCIENCE_TRACK_ID)
+    historyRow.typeId.should.equal(CHALLENGE_TYPE_ID)
+    historyRow.newRating.should.equal(expectedTarget.rating)
+    historyRow.mostRecent.should.equal(true)
+
+    const maxRatingRow = members.state.maxRatingRows.find((row) => String(row.userId) === String(targetUserId))
+    should.exist(maxRatingRow)
+    maxRatingRow.rating.should.equal(expectedTarget.rating)
+    maxRatingRow.track.should.equal('DATA_SCIENCE')
+    maxRatingRow.subTrack.should.equal('Challenge')
+    maxRatingRow.ratingColor.should.equal(getRatingColor(expectedTarget.rating))
+
+    members.state.rankRecalculationCalls.should.have.length(1)
+    members.state.rankRecalculationCalls[0].trackId.should.equal(DATA_SCIENCE_TRACK_ID)
+    members.state.rankRecalculationCalls[0].typeId.should.equal(CHALLENGE_TYPE_ID)
+  })
+
   it('rerateDevTrack should seed rerates from prior history instead of current snapshots', async () => {
     const targetUserId = toBigInt(1001)
     const opponentUserId = toBigInt(2002)