feat: integrate post-request script to the engine - INS-3785,INS-3786

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

@@ -11,6 +11,7 @@ import { unsupportedError } from './properties';
 import { Request as ScriptRequest, RequestOptions, toScriptRequestBody } from './request';
 import { RequestInfo } from './request-info';
 import { Response as ScriptResponse } from './response';
+import { toScriptResponse } from './response';
 import { sendRequest } from './send-request';
 import { test } from './test';
 import { toUrlObject } from './urls';
@@ -23,6 +24,7 @@ export class InsomniaObject {
     public request: ScriptRequest;
     public cookies: CookieObject;
     public info: RequestInfo;
+    public response?: ScriptResponse;
 
     private clientCertificates: ClientCertificate[];
     private _expect = expect;
@@ -47,6 +49,7 @@ export class InsomniaObject {
             clientCertificates: ClientCertificate[];
             cookies: CookieObject;
             requestInfo: RequestInfo;
+            response?: ScriptResponse;
         },
         log: (...msgs: any[]) => void,
     ) {
@@ -57,6 +60,7 @@ export class InsomniaObject {
         this._iterationData = rawObj.iterationData;
         this.variables = rawObj.variables;
         this.cookies = rawObj.cookies;
+        this.response = rawObj.response;
 
         this.info = rawObj.requestInfo;
         this.request = rawObj.request;
@@ -108,11 +112,12 @@ export class InsomniaObject {
             clientCertificates: this.clientCertificates,
             cookieJar: this.cookies.jar().toInsomniaCookieJar(),
             info: this.info.toObject(),
+            response: this.response ? this.response.toObject() : undefined,
         };
     };
 }
 
-export function initInsomniaObject(
+export async function initInsomniaObject(
     rawObj: RequestContext,
     log: (...args: any[]) => void,
 ) {
@@ -206,6 +211,8 @@ export function initInsomniaObject(
     };
     const request = new ScriptRequest(reqOpt);
 
+    const response = rawObj.response ? await toScriptResponse(request, rawObj.response) : undefined;
+
     return new InsomniaObject(
         {
             globals,
@@ -218,6 +225,7 @@ export function initInsomniaObject(
             clientCertificates: rawObj.clientCertificates,
             cookies,
             requestInfo,
+            response,
         },
         log,
     );

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

@@ -2,6 +2,7 @@ import { CookieJar as InsomniaCookieJar } from 'insomnia/src//models/cookie-jar'
 import { ClientCertificate } from 'insomnia/src/models/client-certificate';
 import type { Request } from 'insomnia/src/models/request';
 import { Settings } from 'insomnia/src/models/settings';
+import { sendCurlAndWriteTimelineError, sendCurlAndWriteTimelineResponse } from 'insomnia/src/network/network';
 
 export interface RequestContext {
     request: Request;
@@ -17,4 +18,6 @@ export interface RequestContext {
     settings: Settings;
     clientCertificates: ClientCertificate[];
     cookieJar: InsomniaCookieJar;
+    // only for the post-request script
+    response?: sendCurlAndWriteTimelineResponse | sendCurlAndWriteTimelineError;
 }

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

@@ -1,4 +1,5 @@
 import { RESPONSE_CODE_REASONS } from 'insomnia/src/common/constants';
+import { sendCurlAndWriteTimelineError, type sendCurlAndWriteTimelineResponse } from 'insomnia/src/network/network';
 
 import { Cookie, CookieOptions } from './cookies';
 import { CookieList } from './cookies';
@@ -183,3 +184,64 @@ export class Response extends Property {
         return this.body.toString();
     }
 }
+
+export async function toScriptResponse(
+    originalRequest: Request,
+    partialInsoResponse: sendCurlAndWriteTimelineResponse | sendCurlAndWriteTimelineError,
+): Promise<Response | undefined> {
+    if ('error' in partialInsoResponse) {
+    // it is sendCurlAndWriteTimelineError and basically doesn't contain anything useful
+        return undefined;
+    }
+    const partialResponse = partialInsoResponse as sendCurlAndWriteTimelineResponse;
+
+    const headers = partialResponse.headers ?
+        partialResponse.headers.map(
+            insoHeader => ({
+                key: insoHeader.name,
+                value: insoHeader.value,
+            }),
+            {},
+        )
+        : [];
+
+    const insoCookieOptions = partialResponse.headers ?
+        partialResponse.headers
+            .filter(
+                header => {
+                    return header.name.toLowerCase() === 'set-cookie';
+                },
+                {},
+            ).map(
+                setCookieHeader => Cookie.parse(setCookieHeader.value)
+        )
+        : [];
+
+    let responseBody = '';
+    if (partialResponse.bodyPath) {
+        const readResponseResult = await window.bridge.readCurlResponse({
+            bodyPath: partialResponse.bodyPath,
+            bodyCompression: partialResponse.bodyCompression,
+        });
+
+        if (readResponseResult.error) {
+            throw Error(`Failed to read body: ${readResponseResult.error}`);
+        } else {
+            responseBody = readResponseResult.body;
+        }
+    }
+
+    const responseOption = {
+        code: partialResponse.statusCode || 0,
+        // reason is not provided
+        header: headers,
+        cookie: insoCookieOptions,
+        body: responseBody,
+        // stream is duplicated with body
+        responseTime: partialResponse.elapsedTime,
+        status: partialResponse.statusMessage,
+        originalRequest,
+    };
+
+    return new Response(responseOption);
+};

packages/insomnia/src/hidden-window-preload.ts

@@ -34,7 +34,7 @@ export interface HiddenBrowserWindowToMainBridgeAPI {
   curlRequest: (options: any) => Promise<any>;
   readCurlResponse: (options: { bodyPath: string; bodyCompression: Compression }) => Promise<{ body: string; error: string }>;
   setBusy: (busy: boolean) => void;
-  writeFile: (logPath: string, logContent: string) => Promise<void>;
+  appendFile: (logPath: string, logContent: string) => Promise<void>;
   asyncTasksAllSettled: () => Promise<void>;
   resetAsyncTasks: () => void;
   stopMonitorAsyncTasks: () => void;
@@ -115,8 +115,8 @@ const bridge: HiddenBrowserWindowToMainBridgeAPI = {
   setBusy: busy => ipcRenderer.send('set-hidden-window-busy-status', busy),
   // TODO: following methods are for simulating current behavior of running async tasks
   // in the future, it should be better to keep standard way of handling async tasks to avoid confusion
-  writeFile: (logPath: string, logContent: string) => {
-    return fs.promises.writeFile(logPath, logContent);
+  appendFile: (logPath: string, logContent: string) => {
+    return fs.promises.appendFile(logPath, logContent);
   },
   Promise: OriginalPromise,
   asyncTasksAllSettled,

packages/insomnia/src/hidden-window.ts

@@ -34,7 +34,7 @@ const runPreRequestScript = async (
   console.log(script);
   const scriptConsole = new Console();
 
-  const executionContext = initInsomniaObject(context, scriptConsole.log);
+  const executionContext = await initInsomniaObject(context, scriptConsole.log);
 
   const evalInterceptor = (script: string) => {
     invariant(script && typeof script === 'string', 'eval is called with invalid or empty value');
@@ -83,7 +83,7 @@ const runPreRequestScript = async (
   const updatedCertificates = mergeClientCertificates(context.clientCertificates, mutatedContextObject.request);
   const updatedCookieJar = mergeCookieJar(context.cookieJar, mutatedContextObject.cookieJar);
 
-  await window.bridge.writeFile(context.timelinePath, scriptConsole.dumpLogs());
+  await window.bridge.appendFile(context.timelinePath, scriptConsole.dumpLogs());
 
   console.log('mutatedInsomniaObject', mutatedContextObject);
   console.log('context', context);

packages/insomnia/src/network/network.ts

@@ -73,22 +73,25 @@ export const fetchRequestData = async (requestId: string) => {
   return { request, environment, settings, clientCertificates, caCert, activeEnvironmentId, timelinePath, responseId };
 };
 
-export const tryToExecutePreRequestScript = async (
+export const tryToExecuteScript = async (
+  script: string,
   request: Request,
   environment: Environment,
   timelinePath: string,
   responseId: string,
   baseEnvironment: Environment,
   clientCertificates: ClientCertificate[],
   cookieJar: CookieJar,
+  response?: sendCurlAndWriteTimelineError | sendCurlAndWriteTimelineResponse,
 ) => {
-  if (!request.preRequestScript) {
+  if (!script) {
     return {
       request,
       environment: undefined,
       baseEnvironment: undefined,
     };
   }
+
   const settings = await models.settings.get();
 
   try {
@@ -101,7 +104,7 @@ export const tryToExecutePreRequestScript = async (
       }, timeout + 1000);
     });
     const preRequestPromise = cancellableRunPreRequestScript({
-      script: request.preRequestScript,
+      script,
       context: {
         request,
         timelinePath,
@@ -115,6 +118,7 @@ export const tryToExecutePreRequestScript = async (
         clientCertificates,
         settings,
         cookieJar,
+        response,
       },
     });
     const output = await Promise.race([timeoutPromise, preRequestPromise]) as {
@@ -152,7 +156,10 @@ export const tryToExecutePreRequestScript = async (
       cookieJar: output.cookieJar,
     };
   } catch (err) {
-    await fs.promises.appendFile(timelinePath, JSON.stringify({ value: err.message, name: 'Text', timestamp: Date.now() }) + '\n');
+    await fs.promises.appendFile(
+      timelinePath,
+      JSON.stringify({ value: err.message, name: 'Text', timestamp: Date.now() }) + '\n',
+    );
 
     const requestId = request._id;
     const responsePatch = {
@@ -169,6 +176,50 @@ export const tryToExecutePreRequestScript = async (
   }
 };
 
+export async function tryToExecutePreRequestScript(
+  request: Request,
+  environment: Environment,
+  timelinePath: string,
+  responseId: string,
+  baseEnvironment: Environment,
+  clientCertificates: ClientCertificate[],
+  cookieJar: CookieJar,
+) {
+  return tryToExecuteScript(
+    request.preRequestScript,
+    request,
+    environment,
+    timelinePath,
+    responseId,
+    baseEnvironment,
+    clientCertificates,
+    cookieJar,
+  );
+};
+
+export async function tryToExecutePostRequestScript(
+  request: Request,
+  environment: Environment,
+  timelinePath: string,
+  responseId: string,
+  baseEnvironment: Environment,
+  clientCertificates: ClientCertificate[],
+  cookieJar: CookieJar,
+  response: sendCurlAndWriteTimelineResponse | sendCurlAndWriteTimelineError,
+) {
+  return tryToExecuteScript(
+    request.postRequestScript,
+    request,
+    environment,
+    timelinePath,
+    responseId,
+    baseEnvironment,
+    clientCertificates,
+    cookieJar,
+    response,
+  );
+}
+
 export const tryToInterpolateRequest = async (
   request: Request,
   environment: string | Environment,
@@ -202,14 +253,34 @@ export const tryToTransformRequestWithPlugins = async (renderResult: RequestAndC
     throw new Error(`Failed to transform request with plugins: ${request._id}`);
   }
 };
+
+export interface sendCurlAndWriteTimelineError {
+  _id: string;
+  parentId: string;
+  timelinePath: string;
+  statusMessage: string;
+  // additional
+  url: string;
+  error: string;
+  elapsedTime: number;
+  bytesRead: number;
+}
+
+export interface sendCurlAndWriteTimelineResponse extends ResponsePatch {
+  _id: string;
+  parentId: string;
+  timelinePath: string;
+  statusMessage: string;
+}
+
 export async function sendCurlAndWriteTimeline(
   renderedRequest: RenderedRequest,
   clientCertificates: ClientCertificate[],
   caCert: CaCertificate | null,
   settings: Settings,
   timelinePath: string,
   responseId: string,
-) {
+): Promise<sendCurlAndWriteTimelineError | sendCurlAndWriteTimelineResponse> {
   const requestId = renderedRequest._id;
   const timelineStrings: string[] = [];
   const authentication = renderedRequest.authentication as RequestAuthentication;
@@ -282,6 +353,7 @@ export async function sendCurlAndWriteTimeline(
     ...patch,
   };
 }
+
 export const responseTransform = async (patch: ResponsePatch, environmentId: string | null, renderedRequest: RenderedRequest, context: Record<string, any>) => {
   const response: ResponsePatch = {
     ...patch,