feat: constraints that are in recents will have generated key (#9996)

Previously it was trying to get constraint id for key, but id did not
exist. Now for unique keys, I am using the hashed constraint payload.

frontend/src/component/feature/FeatureStrategy/FeatureStrategyConstraints/RecentlyUsedConstraints/RecentlyUsedConstraints.tsx

@@ -1,9 +1,9 @@
 import { styled, Typography } from '@mui/material';
 import { ConstraintAccordionView } from 'component/common/NewConstraintAccordion/ConstraintAccordionView/ConstraintAccordionView';
-import { constraintId } from 'component/common/LegacyConstraintAccordion/ConstraintAccordionList/createEmptyConstraint';
 import {
     useRecentlyUsedConstraints,
     areConstraintsEqual,
+    getConstraintKey,
 } from './useRecentlyUsedConstraints.ts';
 import type { IConstraint } from 'interfaces/strategy';
 
@@ -55,7 +55,7 @@ export const RecentlyUsedConstraints = ({
             <StyledConstraintsContainer>
                 {nonSelectedRecentConstraints.map((constraint) => (
                     <ConstraintAccordionView
-                        key={constraint[constraintId]}
+                        key={getConstraintKey(constraint)}
                         constraint={constraint}
                         borderStyle='dashed'
                         onUse={() => {

frontend/src/component/feature/FeatureStrategy/FeatureStrategyConstraints/RecentlyUsedConstraints/useRecentlyUsedConstraints.ts

@@ -1,32 +1,43 @@
 import { useLocalStorageState } from 'hooks/useLocalStorageState';
 import type { IConstraint } from 'interfaces/strategy';
 
+const hashString = (str: string): number => {
+    let hash = 0;
+    if (str.length === 0) return hash;
+
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash = hash & hash;
+    }
+
+    return Math.abs(hash);
+};
+
+export const getConstraintKey = (constraint: IConstraint): string => {
+    const sortedValues = (values?: string[]) =>
+        values ? [...values].sort() : undefined;
+
+    const jsonString = JSON.stringify({
+        contextName: constraint.contextName,
+        operator: constraint.operator,
+        values: sortedValues(constraint.values),
+        value: constraint.value,
+        inverted: constraint.inverted,
+        caseInsensitive: constraint.caseInsensitive,
+    });
+
+    return hashString(jsonString).toString();
+};
+
 export const areConstraintsEqual = (
     a: IConstraint,
     b: IConstraint,
 ): boolean => {
-    const sortedValues = (values?: string[]) =>
+    const aKey = getConstraintKey(a);
-        values ? [...values].sort() : undefined;
+    const bKey = getConstraintKey(b);
 
-    const aJson = JSON.stringify({
+    return aKey === bKey;
-        contextName: a.contextName,
-        operator: a.operator,
-        values: sortedValues(a.values),
-        value: a.value,
-        inverted: a.inverted,
-        caseInsensitive: a.caseInsensitive,
-    });
-
-    const bJson = JSON.stringify({
-        contextName: b.contextName,
-        operator: b.operator,
-        values: sortedValues(b.values),
-        value: b.value,
-        inverted: b.inverted,
-        caseInsensitive: b.caseInsensitive,
-    });
-
-    return aJson === bJson;
 };
 
 export const useRecentlyUsedConstraints = (