fix merge confliicts

Author: prayas17

src/modules/common/models/collection.model.ts

@@ -1158,3 +1158,12 @@ export class CollectionDto {
   @IsOptional()
   activeSync?: boolean;
 }
+
+export interface RequestBodyDto {
+  raw?: string;
+  urlencoded?: { key: string; value: string; checked: boolean }[];
+  formdata?: {
+    text?: { key: string; value: string; checked: boolean }[];
+    file?: any[];
+  };
+}

src/modules/workspace/controllers/collection.controller.ts

@@ -1604,7 +1604,7 @@ export class collectionController {
   /**
    * Endpoint to Generate the Variables of whole Collection using AI.
    */
-  @Post("generate-variables/:collectionId")
+  @Post(":collectionId/generate-variables")
   @ApiOperation({
     summary: "Generate Variables",
     description:
@@ -1640,7 +1640,7 @@ export class collectionController {
    * @param KeyValuePairs[] The collectionId.
    * @returns The response object with status and data.
    */
-  @Post("generate-variables/insert")
+  @Post(":collectionId/insert-variables")
   @ApiOperation({
     summary: "Insert Generated Variables into Collection",
     description:
@@ -1656,21 +1656,23 @@ export class collectionController {
     description: "Failed to add a Generate Variables.",
   })
   async addGeneratedVariables(
+    @Param("collectionId") collectionId: string,
     @Body() content: CollectionGeneratedVariableDto,
     @Res() res: FastifyReply,
     @Req() request: ExtendedFastifyRequest,
   ) {
     const user = request.user;
-    const response = await this.collectionService.insertGeneratedVariables(
-      content.collectionId,
+    await this.collectionService.insertGeneratedVariables(
+      collectionId,
       content.generatedeVariables,
       content.workspaceId,
       user,
     );
+    const collection = await this.collectionService.getCollection(collectionId);
     const responseData = new ApiResponseService(
       "Generated Variables Inserted Successfully",
       HttpStatusCode.OK,
-      response,
+      collection,
     );
     return res.status(responseData.httpStatusCode).send(responseData);
   }

src/modules/workspace/schedulers/ai-consumption.scheduler.ts

@@ -31,7 +31,7 @@ export class AiConsumptionScheduler {
     return { start, end };
   }
 
-  @Cron(CronExpression.EVERY_5_MINUTES)
+  @Cron(CronExpression.EVERY_WEEK)
   async handleConsumption() {
     // This method will handle the AI consumption logic.
     // It can be used to schedule tasks related to AI consumption.

src/modules/workspace/services/collection.service.ts

@@ -50,6 +50,7 @@ import {
 import { DecodedUserObject } from "@src/types/fastify";
 import { EncryptionService } from "@src/modules/common/services/encryption.service";
 import { VariableDto } from "@src/modules/common/models/environment.model";
+import { RequestBodyDto } from "@src/modules/common/models/collection.model";
 
 @Injectable()
 export class CollectionService {
@@ -1142,35 +1143,88 @@ export class CollectionService {
     generatedVariables: VariableDto[],
     requestItem: any,
   ): any {
-    // Recursive function to deeply replace matches
-    const replaceValues = (obj: any, path: string = ""): any => {
-      if (Array.isArray(obj)) {
-        return obj.map((item, index) =>
-          replaceValues(item, `${path}[${index}]`),
-        );
-      } else if (obj && typeof obj === "object") {
-        const newObj: any = {};
-        for (const [key, value] of Object.entries(obj)) {
-          newObj[key] = replaceValues(value, `${path}.${key}`);
-        }
-        return newObj;
-      } else if (typeof obj === "string") {
-        for (const variable of generatedVariables) {
-          if (obj === variable.value) {
-            return `{{${variable.key}}}`;
+    // Helper: replace only outside {{ }} blocks
+    const replaceOutsideBraces = (text: string): string => {
+      return text.replace(
+        /(\{\{.*?\}\})|([^{}]+)/g,
+        (match, insideBraces, outside) => {
+          if (insideBraces) return insideBraces;
+          let updated = outside;
+          for (const variable of generatedVariables) {
+            if (updated === variable.value) {
+              updated = `{{${variable.key}}}`;
+            } else if (updated.includes(variable.value)) {
+              updated = updated.replace(
+                new RegExp(variable.value, "g"),
+                `{{${variable.key}}}`,
+              );
+            }
+          }
+          return updated;
+        },
+      );
+    };
+
+    // Special updater for array of key-value objects
+    const updateKeyValueArray = (arr: any[]) => {
+      return arr.map((entry) => ({
+        ...entry,
+        key:
+          typeof entry.key === "string"
+            ? replaceOutsideBraces(entry.key)
+            : entry.key,
+        value:
+          typeof entry.value === "string"
+            ? replaceOutsideBraces(entry.value)
+            : entry.value,
+      }));
+    };
+
+    // Main recursive update
+    const replaceValues = (obj: any): any => {
+      if (!obj || typeof obj !== "object") {
+        return typeof obj === "string" ? replaceOutsideBraces(obj) : obj;
+      }
+      const newObj: any = Array.isArray(obj) ? [] : {};
+      for (const [key, value] of Object.entries(obj)) {
+        if (key === "url" && typeof value === "string") {
+          newObj[key] = replaceOutsideBraces(value);
+        } else if (key === "headers" && Array.isArray(value)) {
+          newObj[key] = updateKeyValueArray(value);
+        } else if (key === "queryParams" && Array.isArray(value)) {
+          newObj[key] = updateKeyValueArray(value);
+        } else if (
+          key === "body" &&
+          typeof value === "object" &&
+          value !== null
+        ) {
+          const updatedBody = { ...(value as RequestBodyDto) };
+          if (typeof updatedBody.raw === "string") {
+            updatedBody.raw = replaceOutsideBraces(updatedBody.raw);
           }
-          if (obj.includes(variable.value)) {
-            obj = obj.replace(
-              new RegExp(variable.value, "g"),
-              `{{${variable.key}}}`,
+          if (Array.isArray(updatedBody.urlencoded)) {
+            updatedBody.urlencoded = updateKeyValueArray(
+              updatedBody.urlencoded,
             );
           }
+          if (
+            updatedBody.formdata &&
+            typeof updatedBody.formdata === "object"
+          ) {
+            if (Array.isArray(updatedBody.formdata.text)) {
+              updatedBody.formdata.text = updateKeyValueArray(
+                updatedBody.formdata.text,
+              );
+            }
+          }
+          newObj[key] = updatedBody;
+        } else {
+          newObj[key] = replaceValues(value);
         }
-        return obj;
       }
-      return obj;
+      return newObj;
     };
-    return replaceValues(requestItem, "root");
+    return replaceValues(requestItem);
   }
 
   public async insertGeneratedVariables(
@@ -1190,17 +1244,30 @@ export class CollectionService {
     }
     const traverseAndUpdate = (items: any[]) => {
       for (const item of items) {
-        if (
-          item.type === ItemTypeEnum.REQUEST ||
-          item.type === ItemTypeEnum.GRAPHQL ||
-          item.type === ItemTypeEnum.SOCKETIO ||
-          item.type === ItemTypeEnum.WEBSOCKET
-        ) {
+        if (item.type === ItemTypeEnum.REQUEST) {
           item.request = this.updatedRequestInCollection(
             generatedPairs,
             item.request,
           );
         }
+        if (item.type === ItemTypeEnum.SOCKETIO) {
+          item.socketio = this.updatedRequestInCollection(
+            generatedPairs,
+            item.socketio,
+          );
+        }
+        if (item.type === ItemTypeEnum.WEBSOCKET) {
+          item.websocket = this.updatedRequestInCollection(
+            generatedPairs,
+            item.websocket,
+          );
+        }
+        if (item.type === ItemTypeEnum.GRAPHQL) {
+          item.graphql = this.updatedRequestInCollection(
+            generatedPairs,
+            item.graphql,
+          );
+        }
         // If folder or item has nested items
         if (Array.isArray(item.items) && item.items.length > 0) {
           traverseAndUpdate(item.items);