insomnia/plugins/insomnia-plugin-response/index.js

const jq = require('jsonpath');
const iconv = require('iconv-lite');
const { query: queryXPath } = require('insomnia-xpath');

module.exports.templateTags = [
  {
    name: 'response',
    displayName: 'Response',
    description: "reference values from other request's responses",
    args: [
      {
        displayName: 'Attribute',
        type: 'enum',
        options: [
          {
            displayName: 'Body Attribute',
            description: 'value of response body',
            value: 'body'
          },
          {
            displayName: 'Raw Body',
            description: 'entire response body',
            value: 'raw'
          },
          {
            displayName: 'Header',
            description: 'value of response header',
            value: 'header'
          }
        ]
      },
      {
        displayName: 'Request',
        type: 'model',
        model: 'Request'
      },
      {
        type: 'string',
        hide: args => args[0].value === 'raw',
        displayName: args => {
          switch (args[0].value) {
            case 'body':
              return 'Filter (JSONPath or XPath)';
            case 'header':
              return 'Header Name';
            default:
              return 'Filter';
          }
        }
      }
    ],

    async run(context, field, id, filter) {
      filter = filter || '';

      if (!['body', 'header', 'raw'].includes(field)) {
        throw new Error(`Invalid response field ${field}`);
      }

      if (!id) {
        throw new Error('No request specified');
      }

      const request = await context.util.models.request.getById(id);
      if (!request) {
        throw new Error(`Could not find request ${id}`);
      }

      const response = await context.util.models.response.getLatestForRequestId(
        id
      );

      if (!response) {
        throw new Error('No responses for request');
      }

      if (!response.statusCode) {
        throw new Error('No successful responses for request');
      }

      if (field !== 'raw' && !filter) {
        throw new Error(`No ${field} filter specified`);
      }

      const sanitizedFilter = filter.trim();

      if (field === 'header') {
        return matchHeader(response.headers, sanitizedFilter);
      } else if (field === 'raw') {
        const bodyBuffer = context.util.models.response.getBodyBuffer(
          response,
          ''
        );
        const match = response.contentType.match(/charset=([\w-]+)/);
        const charset = match && match.length >= 2 ? match[1] : 'utf-8';

        // Sometimes iconv conversion fails so fallback to regular buffer
        try {
          return iconv.decode(bodyBuffer, charset);
        } catch (err) {
          console.warn('[response] Failed to decode body', err);
          return bodyBuffer.toString();
        }
      } else if (field === 'body') {
        const bodyBuffer = context.util.models.response.getBodyBuffer(
          response,
          ''
        );
        const match = response.contentType.match(/charset=([\w-]+)/);
        const charset = match && match.length >= 2 ? match[1] : 'utf-8';

        // Sometimes iconv conversion fails so fallback to regular buffer
        let body;
        try {
          body = iconv.decode(bodyBuffer, charset);
        } catch (err) {
          body = bodyBuffer.toString();
          console.warn('[response] Failed to decode body', err);
        }

        if (sanitizedFilter.indexOf('$') === 0) {
          return matchJSONPath(body, sanitizedFilter);
        } else {
          return matchXPath(body, sanitizedFilter);
        }
      } else {
        throw new Error(`Unknown field ${field}`);
      }
    }
  }
];

function matchJSONPath(bodyStr, query) {
  let body;
  let results;

  try {
    body = JSON.parse(bodyStr);
  } catch (err) {
    throw new Error(`Invalid JSON: ${err.message}`);
  }

  try {
    results = jq.query(body, query);
  } catch (err) {
    throw new Error(`Invalid JSONPath query: ${query}`);
  }

  if (results.length === 0) {
    throw new Error(`Returned no results: ${query}`);
  } else if (results.length > 1) {
    throw new Error(`Returned more than one result: ${query}`);
  }

  if (typeof results[0] !== 'string') {
    return JSON.stringify(results[0]);
  } else {
    return results[0];
  }
}

function matchXPath(bodyStr, query) {
  const results = queryXPath(bodyStr, query);

  if (results.length === 0) {
    throw new Error(`Returned no results: ${query}`);
  } else if (results.length > 1) {
    throw new Error(`Returned more than one result: ${query}`);
  }

  return results[0].inner;
}

function matchHeader(headers, name) {
  if (!headers.length) {
    throw new Error(`No headers available`);
  }

  const header = headers.find(h => h.name.toLowerCase() === name.toLowerCase());

  if (!header) {
    const names = headers.map(c => `"${c.name}"`).join(',\n\t');
    throw new Error(
      `No header with name "${name}".\nChoices are [\n\t${names}\n]`
    );
  }

  return header.value;
}