feat(sdk): enable folder env interfaces for manipulation in script

packages/insomnia-sdk/src/objects/folders.ts

@@ -0,0 +1,60 @@
+import { Environment } from './environments';
+
+// Folder reprensents a request folder in Insomnia.
+export class Folder {
+    id: string;
+    name: string;
+    environment: Environment;
+
+    constructor(id: string, name: string, environmentObject: object | undefined) {
+        this.id = id;
+        this.name = name;
+        this.environment = new Environment(`${id}.environment`, environmentObject);
+    }
+
+    toObject = () => {
+        return {
+            id: this.id,
+            name: this.name,
+            environment: this.environment.toObject(),
+        };
+    };
+}
+
+// ParentFolders reprensents ancestor folders of the active request
+export class ParentFolders {
+    constructor(private folders: Folder[]) { }
+
+    get = (idOrName: string) => {
+        const folder = this.folders.find(folder => folder.name === idOrName || folder.id === idOrName);
+        if (!folder) {
+            throw Error(`Folder "${idOrName}" not found`);
+        }
+        return folder;
+    };
+
+    getById = (id: string) => {
+        const folder = this.folders.find(folder => folder.id === id);
+        if (!folder) {
+            throw Error(`Folder "${id}" not found`);
+        }
+        return folder;
+    };
+
+    getByName = (folderName: string) => {
+        const folder = this.folders.find(folder => folder.name === folderName);
+        if (!folder) {
+            throw Error(`Folder "${folderName}" not found`);
+        }
+        return folder;
+    };
+
+    findValue = (valueKey: string) => {
+        const targetEnv = [...this.folders].reverse().find(folder => folder.environment.has(valueKey));
+        return targetEnv !== undefined ? targetEnv.environment.get(valueKey) : undefined;
+    };
+
+    toObject = () => {
+        return this.folders.map(folder => folder.toObject());
+    };
+}

packages/insomnia-sdk/src/objects/insomnia.ts

@@ -9,6 +9,7 @@ import { getExistingConsole } from './console';
 import { CookieObject } from './cookies';
 import { Environment, Variables } from './environments';
 import { Execution } from './execution';
+import { Folder, ParentFolders } from './folders';
 import type { RequestContext } from './interfaces';
 import { transformToSdkProxyOptions } from './proxy-configs';
 import { Request as ScriptRequest, type RequestOptions, toScriptRequestBody } from './request';
@@ -42,6 +43,8 @@ export class InsomniaObject {
 
     private requestTestResults: RequestTestResult[];
 
+    private parentFolders: ParentFolders;
+
     constructor(
         rawObj: {
             globals: Environment;
@@ -56,6 +59,7 @@ export class InsomniaObject {
             requestInfo: RequestInfo;
             execution: Execution;
             response?: ScriptResponse;
+            parentFolders: ParentFolders;
         },
     ) {
         this.globals = rawObj.globals;
@@ -74,6 +78,7 @@ export class InsomniaObject {
         this.clientCertificates = rawObj.clientCertificates;
 
         this.requestTestResults = new Array<RequestTestResult>();
+        this.parentFolders = rawObj.parentFolders;
     }
 
     sendRequest(
@@ -102,7 +107,6 @@ export class InsomniaObject {
         return this._expect(exp);
     }
 
-    // TODO: remove this after enabled iterationData
     get settings() {
         return undefined;
     }
@@ -122,6 +126,7 @@ export class InsomniaObject {
             response: this.response ? this.response.toObject() : undefined,
             requestTestResults: this.requestTestResults,
             execution: this.execution.toObject(),
+            parentFolders: this.parentFolders.toObject(),
         };
     };
 }
@@ -237,6 +242,14 @@ export async function initInsomniaObject(
     const responseBody = await readBodyFromPath(rawObj.response);
     const response = rawObj.response ? toScriptResponse(request, rawObj.response, responseBody) : undefined;
 
+    const parentFolders = new ParentFolders(rawObj.parentFolders.map(folderObj =>
+        new Folder(
+            folderObj.id,
+            folderObj.name,
+            folderObj.environment,
+        )
+    ));
+
     return new InsomniaObject({
         globals,
         environment,
@@ -250,5 +263,6 @@ export async function initInsomniaObject(
         requestInfo,
         response,
         execution,
+        parentFolders,
     });
 };

packages/insomnia-sdk/src/objects/interfaces.ts

@@ -32,4 +32,5 @@ export interface RequestContext {
     execution: ExecutionOption;
     logs: string[];
     transientVariables?: Omit<IEnvironment, 'id'>;
+    parentFolders: { id: string; name: string; environment: Record<string, any> }[];
 }

packages/insomnia-smoke-test/fixtures/pre-request-collection.yaml

@@ -1382,3 +1382,107 @@ resources:
           "onlySetByFolderPreScript": {{ onlySetByFolderPreScript }}
         }
     _type: request
+  - _id: fld_01de564274824ecaad272330339ea6b3
+    parentId: wrk_6b9b8455fd784462ae19cd51d7156f86
+    modified: 1668533312225
+    created: 1668533312225
+    name: folder1
+    description: ""
+    environment:
+      val: "1"
+    environmentPropertyOrder: null
+    metaSortKey: -1668533312225
+    _type: request_group
+    afterResponseScript: ""
+    preRequestScript: |-
+      const folder1ValByFolder1 = insomnia.parentFolders.get('folder1').environment.get('val');
+      const folder1ValByFolder1ByName = insomnia.parentFolders.getByName('folder1').environment.get('val');
+      const folder2ValByFolder1 = insomnia.parentFolders.get('folder2').environment.get('val');
+      const folder2ValByFolder1ByName = insomnia.parentFolders.getByName('folder2').environment.get('val');
+      const valFoundByFolder1 = insomnia.parentFolders.findValue('val');
+
+      insomnia.environment.set('folder1ValByFolder1', folder1ValByFolder1);
+      insomnia.environment.set('folder1ValByFolder1ByName', folder1ValByFolder1ByName);
+      insomnia.environment.set('folder2ValByFolder1', folder2ValByFolder1);
+      insomnia.environment.set('folder2ValByFolder1ByName', folder2ValByFolder1ByName);
+      insomnia.environment.set('valFoundByFolder1', valFoundByFolder1);
+  - _id: fld_01de564274824ecaad272330339ea6b4
+    parentId: fld_01de564274824ecaad272330339ea6b3
+    modified: 1668533312225
+    created: 1668533312225
+    name: folder2
+    description: ""
+    environment:
+      val: "2"
+    environmentPropertyOrder: null
+    metaSortKey: -1668533312225
+    _type: request_group
+    afterResponseScript: ""
+    preRequestScript: |-
+      const folder1ValByFolder2 = insomnia.parentFolders.get('folder1').environment.get('val');
+      const folder1ValByFolder2ByName = insomnia.parentFolders.getByName('folder1').environment.get('val');
+      const folder2ValByFolder2 = insomnia.parentFolders.get('folder2').environment.get('val');
+      const folder2ValByFolder2ByName = insomnia.parentFolders.getByName('folder2').environment.get('val');
+      const valFoundByFolder2 = insomnia.parentFolders.findValue('val');
+
+      insomnia.environment.set('folder1ValByFolder2', folder1ValByFolder2);
+      insomnia.environment.set('folder1ValByFolder2ByName', folder1ValByFolder2ByName);
+      insomnia.environment.set('folder2ValByFolder2', folder2ValByFolder2);
+      insomnia.environment.set('folder2ValByFolder2ByName', folder2ValByFolder2ByName);
+      insomnia.environment.set('valFoundByFolder2', valFoundByFolder2);
+  - _id: req_89dade2ee9ee42fbb22d588783a9df21
+    parentId: fld_01de564274824ecaad272330339ea6b4
+    modified: 1636707449231
+    created: 1636141014552
+    url: http://127.0.0.1:4010/echo
+    name: manipulate folder envs
+    description: ""
+    method: POST
+    parameters: []
+    headers:
+      - name: 'Content-Type'
+        value: 'application/json'
+    authentication: {}
+    metaSortKey: -1636141014553
+    isPrivate: false
+    settingStoreCookies: true
+    settingSendCookies: true
+    settingDisableRenderRequestBody: false
+    settingEncodeUrl: true
+    settingRebuildPath: true
+    settingFollowRedirects: global
+    preRequestScript: |-
+      const folder1ValByReq = insomnia.parentFolders.get('folder1').environment.get('val');
+      const folder1ValByReqByName = insomnia.parentFolders.getByName('folder1').environment.get('val');
+      const folder2ValByReq = insomnia.parentFolders.get('folder2').environment.get('val');
+      const folder2ValByReqByName = insomnia.parentFolders.getByName('folder2').environment.get('val');
+      const valFound = insomnia.parentFolders.findValue('val');
+
+      insomnia.environment.set('folder1ValByReq', folder1ValByReq);
+      insomnia.environment.set('folder1ValByReqByName', folder1ValByReqByName);
+      insomnia.environment.set('folder2ValByReq', folder2ValByReq);
+      insomnia.environment.set('folder2ValByReqByName', folder2ValByReqByName);
+      insomnia.environment.set('valFound', valFound);
+    body:
+      mimeType: "application/json"
+      text: |-
+        {
+          "folder1ValByReq": {{ folder1ValByReq }},
+          "folder1ValByReqByName": {{ folder1ValByReqByName }},
+          "folder2ValByReq": {{ folder2ValByReq }},
+          "folder2ValByReqByName": {{ folder2ValByReqByName }},
+          "valFound": {{ valFound }},
+
+          "folder1ValByFolder1": {{ folder1ValByFolder1 }},
+          "folder1ValByFolder1ByName": {{ folder1ValByFolder1ByName }},
+          "folder2ValByFolder1": {{ folder2ValByFolder1 }},
+          "folder2ValByFolder1ByName": {{ folder2ValByFolder1ByName }},
+          "valFoundByFolder1": {{ valFoundByFolder1 }},
+
+          "folder1ValByFolder2": {{ folder1ValByFolder2 }},
+          "folder1ValByFolder2ByName": {{ folder1ValByFolder2ByName }},
+          "folder2ValByFolder2": {{ folder2ValByFolder2 }},
+          "folder2ValByFolder2ByName": {{ folder2ValByFolder2ByName }},
+          "valFoundByFolder2": {{ valFoundByFolder2 }}
+        }
+    _type: request

packages/insomnia-smoke-test/tests/smoke/pre-request-script-features.test.ts

@@ -179,6 +179,28 @@ test.describe('pre-request features tests', async () => {
                 'onlySetByFolderPreScript': 888,
             },
         },
+        {
+            name: 'manipulate folder envs',
+            expectedBody: {
+                'folder1ValByReq': 1,
+                'folder1ValByReqByName': 1,
+                'folder2ValByReq': 2,
+                'folder2ValByReqByName': 2,
+                'valFound': 2,
+
+                'folder1ValByFolder1': 1,
+                'folder1ValByFolder1ByName': 1,
+                'folder2ValByFolder1': 2,
+                'folder2ValByFolder1ByName': 2,
+                'valFoundByFolder1': 2,
+
+                'folder1ValByFolder2': 1,
+                'folder1ValByFolder2ByName': 1,
+                'folder2ValByFolder2': 2,
+                'folder2ValByFolder2ByName': 2,
+                'valFoundByFolder2': 2,
+            },
+        },
     ];
 
     for (let i = 0; i < testCases.length; i++) {

packages/insomnia/src/hidden-window.ts

@@ -120,6 +120,7 @@ const runScript = async (
     globals: mutatedContextObject.globals,
     requestTestResults: mutatedContextObject.requestTestResults,
     logs: scriptConsole.dumpLogsAsArray(),
+    parentFolders: mutatedContextObject.parentFolders,
   };
 };
 

packages/insomnia/src/network/concurrency.ts

@@ -39,6 +39,7 @@ export interface TransformedExecuteScriptContext {
     cookieJar: CookieJar;
     requestTestResults?: RequestTestResult[];
     userUploadEnvironment?: UserUploadEnvironment;
+    parentFolders: { id: string; name: string; environment: Record<string, any> }[];
 }
 
 interface Task {