#RI-5724 add retries for data chatbot + disable flags + small fixes

Author: ArtemHoruzhenko

redisinsight/api/config/features-config.json

@@ -1,5 +1,5 @@
 {
-  "version": 2.4602,
+  "version": 2.4603,
   "features": {
     "insightsRecommendations": {
       "flag": true,
@@ -47,28 +47,6 @@
         }
       }
     },
-    "documentationChat": {
-      "flag": true,
-      "perc": [[0,100]],
-      "filters": [
-        {
-          "name": "config.server.buildType",
-          "value": "ELECTRON",
-          "cond": "eq"
-        }
-      ]
-    },
-    "databaseChat": {
-      "flag": true,
-      "perc": [[0,100]],
-      "filters": [
-        {
-          "name": "config.server.buildType",
-          "value": "ELECTRON",
-          "cond": "eq"
-        }
-      ]
-    },
     "cloudSsoRecommendedSettings": {
       "flag": true,
       "perc": [[0, 100]],

redisinsight/api/src/modules/ai/query/ai-query.service.ts

@@ -137,7 +137,7 @@ export class AiQueryService {
             index,
           );
 
-          if (!context) {
+          if (!indexContext) {
             return cb(await this.aiQueryContextRepository.setIndexContext(
               sessionMetadata,
               databaseId,
@@ -193,23 +193,27 @@ export class AiQueryService {
   }
 
   async getHistory(sessionMetadata: SessionMetadata, databaseId: string): Promise<AiQueryMessage[]> {
-    try {
-      const auth = await this.aiQueryAuthProvider.getAuthData(sessionMetadata);
-      return await this.aiQueryMessageRepository.list(sessionMetadata, databaseId, auth.accountId);
-    } catch (e) {
-      throw wrapAiQueryError(e, 'Unable to get history');
-    }
+    return this.aiQueryAuthProvider.callWithAuthRetry(sessionMetadata, async () => {
+      try {
+        const auth = await this.aiQueryAuthProvider.getAuthData(sessionMetadata);
+        return await this.aiQueryMessageRepository.list(sessionMetadata, databaseId, auth.accountId);
+      } catch (e) {
+        throw wrapAiQueryError(e, 'Unable to get history');
+      }
+    });
   }
 
   async clearHistory(sessionMetadata: SessionMetadata, databaseId: string): Promise<void> {
-    try {
-      const auth = await this.aiQueryAuthProvider.getAuthData(sessionMetadata);
+    return this.aiQueryAuthProvider.callWithAuthRetry(sessionMetadata, async () => {
+      try {
+        const auth = await this.aiQueryAuthProvider.getAuthData(sessionMetadata);
 
-      await this.aiQueryContextRepository.reset(sessionMetadata, databaseId, auth.accountId);
+        await this.aiQueryContextRepository.reset(sessionMetadata, databaseId, auth.accountId);
 
-      return this.aiQueryMessageRepository.clearHistory(sessionMetadata, databaseId, auth.accountId);
-    } catch (e) {
-      throw wrapAiQueryError(e, 'Unable to clear history');
-    }
+        return this.aiQueryMessageRepository.clearHistory(sessionMetadata, databaseId, auth.accountId);
+      } catch (e) {
+        throw wrapAiQueryError(e, 'Unable to clear history');
+      }
+    });
   }
 }

redisinsight/api/src/modules/feature/feature.service.spec.ts

@@ -108,7 +108,7 @@ describe('FeatureService', () => {
       await service.recalculateFeatureFlags();
 
       expect(repository.delete)
-        .toHaveBeenCalledWith(mockUnknownFeature);
+        .toHaveBeenCalledWith(mockUnknownFeature.name);
       expect(repository.upsert)
         .toHaveBeenCalledWith({
           name: KnownFeatures.InsightsRecommendations,

redisinsight/api/src/modules/feature/feature.service.ts

@@ -112,7 +112,7 @@ export class FeatureService {
       actions.toDelete = featuresFromDatabase.filter((feature) => !featuresConfig?.data?.features?.has?.(feature.name));
 
       // delete features
-      await Promise.all(actions.toDelete.map((feature) => this.repository.delete(feature)));
+      await Promise.all(actions.toDelete.map((feature) => this.repository.delete(feature.name)));
       // upsert modified features
       await Promise.all(actions.toUpsert.map((feature) => this.repository.upsert(feature)));
 

redisinsight/api/src/modules/feature/providers/feature-flag/strategies/switchable.flag.strategy.spec.ts

@@ -66,7 +66,7 @@ describe('SwitchableFlagStrategy', () => {
       ))
         .toEqual({
           name: KnownFeatures.DatabaseChat,
-          flag: false,
+          flag: expect.any(Boolean),
         });
 
       expect(isInTargetRangeSpy).toHaveBeenCalled();
@@ -240,5 +240,30 @@ describe('SwitchableFlagStrategy', () => {
       expect(isInTargetRangeSpy).toHaveBeenCalled();
       expect(filterSpy).toHaveBeenCalled();
     });
+
+    it('should return flag:false even if feature force enabled but flag in config = false', async () => {
+      isInTargetRangeSpy.mockReturnValueOnce(true);
+      filterSpy.mockReturnValueOnce(true);
+      mockedFs.readFile.mockResolvedValueOnce(JSON.stringify({
+        features: {
+          [KnownFeatures.DatabaseChat]: true,
+        },
+      }) as any);
+
+      expect(await service.calculate(
+        knownFeatures[KnownFeatures.DatabaseChat],
+        {
+          perc: [[0, 100]],
+          flag: false,
+        },
+      ))
+        .toEqual({
+          name: KnownFeatures.DatabaseChat,
+          flag: false,
+        });
+
+      expect(isInTargetRangeSpy).toHaveBeenCalled();
+      expect(filterSpy).toHaveBeenCalled();
+    });
   });
 });

redisinsight/api/src/modules/feature/providers/feature-flag/strategies/switchable.flag.strategy.ts

@@ -5,14 +5,16 @@ import { IFeatureFlag } from 'src/modules/feature/constants';
 export class SwitchableFlagStrategy extends FeatureFlagStrategy {
   async calculate(knownFeature: IFeatureFlag, featureConfig: any): Promise<Feature> {
     const isInRange = await this.isInTargetRange(featureConfig?.perc);
-    const isInFilter = await this.filter(featureConfig?.filters) ? !!featureConfig.flag : !featureConfig?.flag;
-    const force = (await FeatureFlagStrategy.getCustomConfig())?.[knownFeature.name];
+    const isInFilter = await this.filter(featureConfig?.filters);
+    const originalFlag = !!featureConfig?.flag;
+
+    let flag = (isInRange && isInFilter) ? originalFlag : !originalFlag;
 
-    let flag = isInRange && isInFilter;
+    const force = (await FeatureFlagStrategy.getCustomConfig())?.[knownFeature.name];
 
-    if (isInFilter && force === true) {
+    if (isInFilter && originalFlag && force === true) {
       flag = true;
-    } else if (isInFilter && force === false) {
+    } else if (isInFilter && originalFlag && force === false) {
       flag = false;
     }