tods-competition-factory 1.7.12 → 1.7.13

package/dist/index.mjs

@@ -333,7 +333,7 @@ const matchUpFormatCode = {
 };
 
 function factoryVersion() {
-  return "1.7.12";
+  return "1.7.13";
 }
 
 function getObjectTieFormat(obj) {
@@ -29569,6 +29569,7 @@ function getTieFormat$1({
   // optional - if an eventId is present only return tieFormat for event
   event
 }) {
+  const stack = "getTieFormat";
   let tieFormat;
   structureId = structure?.structureId ?? structureId;
   matchUpId = matchUp?.matchUpId ?? matchUpId;
@@ -29584,6 +29585,9 @@ function getTieFormat$1({
       });
       if (result.error)
         return result;
+      if (result.matchUp?.matchUpType !== TEAM_MATCHUP) {
+        return decorateResult({ result: { error: INVALID_MATCHUP }, stack });
+      }
       if (!structure)
         structure = result.structure;
       if (!matchUp)
@@ -29617,7 +29621,7 @@ function getTieFormat$1({
     tieFormat = getObjectTieFormat(drawDefinition) || getObjectTieFormat(event);
   }
   if (!tieFormat)
-    return decorateResult({ result: { error: MISSING_TIE_FORMAT } });
+    return decorateResult({ result: { error: MISSING_TIE_FORMAT }, stack });
   return { ...SUCCESS, tieFormat, matchUp, structure };
 }
 
@@ -29800,9 +29804,9 @@ function modifyCollectionDefinition$1({
   tournamentRecord,
   collectionOrder,
   collectionName,
+  tieFormatName,
   drawDefinition,
   matchUpFormat,
-  tieFormatName,
   matchUpCount,
   collectionId,
   matchUpType,
@@ -29819,19 +29823,35 @@ function modifyCollectionDefinition$1({
   scoreValue,
   setValue
 }) {
+  const stack = "modifyCollectionDefinition";
   if (matchUpFormat && !isValid(matchUpFormat)) {
-    return { error: INVALID_VALUES };
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      context: { matchUpFormat },
+      stack
+    });
   }
   if (collectionName && typeof collectionName !== "string") {
-    return { error: INVALID_VALUES };
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      context: { collectionName },
+      stack
+    });
   }
   if (gender && !Object.values(genderConstants).includes(gender)) {
-    return { error: INVALID_VALUES };
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      context: { gender },
+      stack
+    });
   }
   if (category && typeof category !== "object") {
-    return { error: INVALID_VALUES };
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      context: { category },
+      stack
+    });
   }
-  const stack = "modifyCollectionDefinition";
   const valueAssignments = {
     collectionValueProfiles,
     collectionValue,
@@ -29843,10 +29863,8 @@ function modifyCollectionDefinition$1({
     return decorateResult({ result: { error: MISSING_VALUE }, stack });
   if (Object.values(valueAssignments).filter(Boolean).length > 1)
     return decorateResult({
-      result: {
-        info: "Only one value assignment allowed per collectionDefinition",
-        error: INVALID_VALUES
-      },
+      info: "Only one value assignment allowed per collectionDefinition",
+      result: { error: INVALID_VALUES },
       stack
     });
   let result = getTieFormat$1({
@@ -29856,79 +29874,137 @@ function modifyCollectionDefinition$1({
     eventId,
     event
   });
-  if (result.error)
+  if (result.error) {
     return decorateResult({ result, stack });
+  }
   const { matchUp, structure, tieFormat: existingTieFormat } = result;
   const tieFormat = copyTieFormat(existingTieFormat);
-  const collectionDefinition = tieFormat.collectionDefinitions.find(
-    (collectionDefinition2) => collectionDefinition2.collectionId === collectionId
+  const sourceCollectionDefinition = existingTieFormat?.collectionDefinitions.find(
+    (collectionDefinition) => collectionDefinition.collectionId === collectionId
   );
-  if (!collectionDefinition)
+  const targetCollectionDefinition = tieFormat?.collectionDefinitions.find(
+    (collectionDefinition) => collectionDefinition.collectionId === collectionId
+  );
+  if (!sourceCollectionDefinition)
     return decorateResult({ result: { error: NOT_FOUND }, stack });
-  const value = collectionValue || matchUpValue || scoreValue || setValue;
-  if (value || collectionValueProfiles) {
-    if (value) {
-      if (!isConvertableInteger(value))
-        return decorateResult({ result: { error: INVALID_VALUES, value } });
-    } else if (collectionValueProfiles) {
-      const result2 = validateCollectionValueProfile({
-        matchUpCount: collectionDefinition.matchUpCount,
-        collectionValueProfiles
-      });
-      if (result2.errors) {
-        return decorateResult({
-          result: { error: INVALID_VALUES, info: result2.errors },
-          stack
-        });
-      }
+  const value = collectionValue ?? matchUpValue ?? scoreValue ?? setValue;
+  if (collectionValueProfiles) {
+    const result2 = validateCollectionValueProfile({
+      matchUpCount: matchUpCount || sourceCollectionDefinition?.matchUpCount,
+      collectionValueProfiles
+    });
+    if (result2.errors) {
+      return decorateResult({
+        result: { error: INVALID_VALUES },
+        info: result2.errors,
+        stack
+      });
     }
-    collectionDefinition.collectionValue = void 0;
-    collectionDefinition.matchUpValue = void 0;
-    collectionDefinition.scoreValue = void 0;
-    collectionDefinition.setValue = void 0;
-    Object.assign(collectionDefinition, valueAssignments);
+  } else if (value && !isConvertableInteger(value)) {
+    return decorateResult({
+      result: { error: INVALID_VALUES },
+      info: "value is not an integer",
+      context: { value },
+      stack
+    });
+  }
+  const equivalentValueProfiles = (a, b) => intersection(Object.keys(a), Object.keys(b)).length === Object.keys(a).length && intersection(Object.values(a), Object.values(b)).length === Object.values(a).length;
+  const valueProfileModified = collectionValueProfiles && (!sourceCollectionDefinition.collectionValueProfiles || !equivalentValueProfiles(
+    sourceCollectionDefinition.collectionValueProfiles,
+    collectionValueProfiles
+  ));
+  const valueModified = isConvertableInteger(collectionValue) && sourceCollectionDefinition.collectionValue !== collectionValue || isConvertableInteger(matchUpValue) && sourceCollectionDefinition.matchUpValue !== matchUpValue || isConvertableInteger(scoreValue) && sourceCollectionDefinition.scoreValue !== scoreValue || isConvertableInteger(setValue) && sourceCollectionDefinition.setValue !== setValue || valueProfileModified;
+  const modifications = [];
+  if (valueModified) {
+    targetCollectionDefinition.collectionValueProfiles = void 0;
+    targetCollectionDefinition.collectionValue = void 0;
+    targetCollectionDefinition.matchUpValue = void 0;
+    targetCollectionDefinition.scoreValue = void 0;
+    targetCollectionDefinition.setValue = void 0;
+    Object.assign(targetCollectionDefinition, valueAssignments);
+    modifications.push({
+      collectionId,
+      ...definedAttributes(valueAssignments)
+    });
   }
-  if ((scoreValue || setValue) && collectionDefinition.collectionGroupNumber) {
-    const targetCollectionGroupNumber = collectionDefinition.collectionGroupNumber;
+  if ((isConvertableInteger(scoreValue) || isConvertableInteger(setValue)) && targetCollectionDefinition.collectionGroupNumber) {
+    const targetCollectionGroupNumber = targetCollectionDefinition.collectionGroupNumber;
     tieFormat.collectionDefinitions = tieFormat.collectionDefinitions.map(
-      (collectionDefinition2) => {
-        const { collectionGroupNumber, ...rest } = collectionDefinition2;
+      (collectionDefinition) => {
+        const { collectionGroupNumber, ...rest } = collectionDefinition;
         if (collectionGroupNumber === targetCollectionGroupNumber) {
           return rest;
         } else {
-          return collectionDefinition2;
+          return collectionDefinition;
         }
       }
     );
     tieFormat.collectionGroups = tieFormat.collectionGroups.filter(
       ({ groupNumber }) => groupNumber !== targetCollectionGroupNumber
     );
+    modifications.push({
+      collectionId,
+      change: "collectionGroupNumber removed"
+    });
   }
   const { aggregateValue, valueGoal } = calculateWinCriteria(tieFormat);
-  tieFormat.winCriteria = definedAttributes({ aggregateValue, valueGoal });
-  const originalValueGoal = existingTieFormat?.winCriteria.valueGoal;
-  const wasAggregateValue = existingTieFormat?.winCriteria.aggregateValue;
-  if (originalValueGoal && originalValueGoal !== valueGoal || aggregateValue && !wasAggregateValue) {
-    delete tieFormat.tieFormatName;
-  }
-  if (tieFormatName)
-    tieFormat.tieFormatName = tieFormatName;
-  if (collectionOrder)
-    collectionDefinition.collectionOrder = collectionOrder;
-  if (collectionName)
-    collectionDefinition.collectionName = collectionName;
-  if (matchUpFormat)
-    collectionDefinition.matchUpFormat = matchUpFormat;
-  if (matchUpType)
-    collectionDefinition.matchUpType = matchUpType;
-  if (category)
-    collectionDefinition.category = category;
-  if (gender)
-    collectionDefinition.gender = gender;
+  const winCriteria = definedAttributes({ aggregateValue, valueGoal });
+  if (winCriteria.aggregateValue !== existingTieFormat?.winCriteria.aggregateValue || winCriteria.valueGoal !== existingTieFormat?.winCriteria.valueGoal) {
+    tieFormat.winCriteria = winCriteria;
+    modifications.push({ collectionId, winCriteria });
+  }
+  if (isConvertableInteger(collectionOrder) && sourceCollectionDefinition.collectionOrder !== collectionOrder) {
+    targetCollectionDefinition.collectionOrder = collectionOrder;
+    modifications.push({ collectionId, collectionOrder });
+  }
+  if (collectionName && sourceCollectionDefinition.collectionName !== collectionName) {
+    targetCollectionDefinition.collectionName = collectionName;
+    modifications.push({ collectionId, collectionName });
+  }
+  if (matchUpFormat && sourceCollectionDefinition.matchUpFormat !== matchUpFormat) {
+    targetCollectionDefinition.matchUpFormat = matchUpFormat;
+    modifications.push({ collectionId, matchUpFormat });
+  }
+  if (isConvertableInteger(matchUpCount) && sourceCollectionDefinition.matchUpCount !== matchUpCount) {
+    return decorateResult({
+      result: { error: NOT_IMPLEMENTED },
+      context: { matchUpCount },
+      stack
+    });
+  }
+  if (matchUpType && sourceCollectionDefinition.matchUpType !== matchUpType) {
+    return decorateResult({
+      result: { error: NOT_IMPLEMENTED },
+      context: { matchUpType },
+      stack
+    });
+  }
+  if (category && sourceCollectionDefinition.category !== category) {
+    targetCollectionDefinition.category = category;
+    modifications.push({ collectionId, category });
+  }
+  if (gender && sourceCollectionDefinition.gender !== gender) {
+    targetCollectionDefinition.gender = gender;
+    modifications.push({ collectionId, gender });
+  }
   const prunedTieFormat = definedAttributes(tieFormat);
   result = validateTieFormat({ tieFormat: prunedTieFormat });
-  if (result.error)
+  if (result.error) {
     return decorateResult({ result, stack });
+  }
+  if (!modifications.length) {
+    return decorateResult({ result: { ...SUCCESS, modifications } });
+  }
+  const changedTieFormatName = existingTieFormat?.tieFormatName !== tieFormatName;
+  if (changedTieFormatName) {
+    prunedTieFormat.tieFormatName = tieFormatName;
+    modifications.push({ tieFormatName });
+  } else if (modifications.length) {
+    delete prunedTieFormat.tieFormatName;
+    modifications.push(
+      "tieFormatName removed: modifications without new tieFormatName"
+    );
+  }
   result = updateTieFormat({
     tieFormat: prunedTieFormat,
     updateInProgressMatchUps,
@@ -29943,8 +30019,8 @@ function modifyCollectionDefinition$1({
     const { appliedPolicies } = getAppliedPolicies({ tournamentRecord });
     if (appliedPolicies?.audit?.[TIE_FORMAT_MODIFICATIONS]) {
       const auditData = definedAttributes({
+        collectionDefinition: targetCollectionDefinition,
         drawId: drawDefinition?.drawId,
-        collectionDefinition,
         action: stack,
         structureId,
         matchUpId,
@@ -29953,7 +30029,7 @@ function modifyCollectionDefinition$1({
       tieFormatTelemetry({ drawDefinition, auditData });
     }
   }
-  return decorateResult({ result, stack });
+  return decorateResult({ result: { ...result, modifications }, stack });
 }
 
 function resolveTournamentRecord(params) {
@@ -30448,10 +30524,10 @@ function addCollectionDefinition$1({
       ({ collectionId }) => collectionId
     );
     if (collectionIds.includes(collectionDefinition.collectionId))
-      return {
-        collectionId: collectionDefinition.collectionId,
-        error: DUPLICATE_VALUE
-      };
+      return decorateResult({
+        context: { collectionId: collectionDefinition.collectionId },
+        result: { error: DUPLICATE_VALUE }
+      });
   }
   tieFormat.collectionDefinitions.push(collectionDefinition);
   tieFormat.collectionDefinitions.sort((a, b) => (a.collectionOrder || 0) - (b.collectionOrder || 0)).forEach(
@@ -30524,7 +30600,10 @@ function addCollectionDefinition$1({
     });
   } else if (matchUpId && matchUp) {
     if (!validUpdate({ matchUp, updateInProgressMatchUps }))
-      return { error: CANNOT_MODIFY_TIEFORMAT };
+      return decorateResult({
+        result: { error: CANNOT_MODIFY_TIEFORMAT },
+        stack
+      });
     matchUp.tieFormat = prunedTieFormat;
     const newMatchUps = generateCollectionMatchUps({
       collectionDefinition,
@@ -30579,10 +30658,10 @@ function addCollectionDefinition$1({
     tieFormatTelemetry({ drawDefinition, auditData });
   }
   return {
-    ...SUCCESS,
     tieFormat: prunedTieFormat,
     targetMatchUps,
-    addedMatchUps
+    addedMatchUps,
+    ...SUCCESS
   };
 }
 function updateStructureMatchUps({
@@ -31113,45 +31192,42 @@ function modifyTieFormat$1({
     return decorateResult({ result, stack });
   const { matchUp, tieFormat: existingTieFormat } = result;
   const tieFormat = copyTieFormat(existingTieFormat);
+  if (!compareTieFormats({ ancestor: tieFormat, descendant: modifiedTieFormat })?.different) {
+    return { ...SUCCESS };
+  }
   const existingCollectionIds = tieFormat.collectionDefinitions.map(
     ({ collectionId }) => collectionId
   );
-  const modifiedCollectionDefinitions = [];
-  const addedCollectionDefinitions = [];
-  const updatedCollectionIds = [];
-  modifiedTieFormat.collectionDefinitions.forEach((def) => {
-    updatedCollectionIds.push(def.collectionId);
-    if (modifiedTieFormat && existingCollectionIds.includes(def.collectionId)) {
-      compareTieFormats({
-        descendant: modifiedTieFormat,
-        ancestor: tieFormat
-      })?.different && modifiedCollectionDefinitions.push(def);
-    } else {
-      addedCollectionDefinitions.push(def);
-    }
-  });
+  const updatedCollectionIds = modifiedTieFormat.collectionDefinitions.map(
+    ({ collectionId }) => collectionId
+  );
   const removedCollectionIds = existingCollectionIds.filter(
     (collectionId) => !updatedCollectionIds.includes(collectionId)
   );
-  const tieFormatName = modifiedTieFormat.tieFormatName;
+  const addedCollectionDefinitions = modifiedTieFormat.collectionDefinitions.filter(
+    ({ collectionId }) => !existingCollectionIds.includes(collectionId)
+  );
+  const modifications = [];
   let processedTieFormat;
-  for (const collectionDefinition of modifiedCollectionDefinitions) {
+  for (const collectionDefinition of modifiedTieFormat.collectionDefinitions) {
     const result2 = modifyCollectionDefinition$1({
       updateInProgressMatchUps,
       ...collectionDefinition,
       tournamentRecord,
       drawDefinition,
-      tieFormatName,
       structureId,
       matchUpId,
       eventId,
       event
     });
+    if (result2.modifications)
+      modifications.push(...result2.modifications);
     if (result2.error)
       return decorateResult({ result: result2, stack });
     if (result2.tieFormat)
       processedTieFormat = result2.tieFormat;
   }
+  const tieFormatName = modifiedTieFormat.tieFormatName;
   for (const collectionDefinition of addedCollectionDefinitions) {
     const result2 = addCollectionDefinition$1({
       updateInProgressMatchUps,
@@ -31190,10 +31266,20 @@ function modifyTieFormat$1({
     if (result2.tieFormat)
       processedTieFormat = result2.tieFormat;
   }
+  const changedTieFormatName = existingTieFormat?.tieFormatName !== tieFormatName;
+  if (changedTieFormatName) {
+    processedTieFormat.tieFormatName = tieFormatName;
+    modifications.push({ tieFormatName });
+  } else if (modifications.length) {
+    delete processedTieFormat.tieFormatName;
+    modifications.push(
+      "tieFormatName removed: modifications without new tieFormatName"
+    );
+  }
   processedTieFormat.collectionDefinitions = processedTieFormat.collectionDefinitions.sort(
     (a, b) => numericSortValue(a.collectionOrder) - numericSortValue(b.collectionOrder)
   ).map((def, i) => ({ ...def, collectionOrder: i + 1 }));
-  return { ...SUCCESS, processedTieFormat };
+  return { ...SUCCESS, processedTieFormat, modifications };
 }
 
 function modifyTieFormat(params) {