@readme/httpsnippet 3.1.1 → 4.0.0

package/src/helpers/code-builder.ts

@@ -0,0 +1,85 @@
+const DEFAULT_INDENTATION_CHARACTER = '';
+const DEFAULT_LINE_JOIN = '\n';
+
+export type PostProcessor = (unreplacedCode: string) => string;
+
+export interface CodeBuilderOptions {
+  /**
+   * Desired indentation character for aggregated lines of code
+   * @default ''
+   */
+  indent?: string;
+
+  /**
+   * Desired character to join each line of code
+   * @default \n
+   */
+  join?: string;
+}
+
+export class CodeBuilder {
+  postProcessors: PostProcessor[] = [];
+
+  code: string[] = [];
+
+  indentationCharacter: string = DEFAULT_INDENTATION_CHARACTER;
+
+  lineJoin = DEFAULT_LINE_JOIN;
+
+  /**
+   * Helper object to format and aggragate lines of code.
+   * Lines are aggregated in a `code` array, and need to be joined to obtain a proper code snippet.
+   */
+  constructor({ indent, join }: CodeBuilderOptions = {}) {
+    this.indentationCharacter = indent || DEFAULT_INDENTATION_CHARACTER;
+    this.lineJoin = join ?? DEFAULT_LINE_JOIN;
+  }
+
+  /**
+   * Add given indentation level to given line of code
+   */
+  indentLine = (line: string, indentationLevel = 0) => {
+    const indent = this.indentationCharacter.repeat(indentationLevel);
+    return `${indent}${line}`;
+  };
+
+  /**
+   * Add the line at the beginning of the current lines
+   */
+  unshift = (line: string, indentationLevel?: number) => {
+    const newLine = this.indentLine(line, indentationLevel);
+    this.code.unshift(newLine);
+  };
+
+  /**
+   * Add the line at the end of the current lines
+   */
+  push = (line: string, indentationLevel?: number) => {
+    const newLine = this.indentLine(line, indentationLevel);
+    this.code.push(newLine);
+  };
+
+  /**
+   * Add an empty line at the end of current lines
+   */
+  blank = () => {
+    this.code.push('');
+  };
+
+  /**
+   * Concatenate all current lines using the given lineJoin, then apply any replacers that may have been added
+   */
+  join = () => {
+    const unreplacedCode = this.code.join(this.lineJoin);
+    const replacedOutput = this.postProcessors.reduce((accumulator, replacer) => replacer(accumulator), unreplacedCode);
+    return replacedOutput;
+  };
+
+  /**
+   * Often when writing modules you may wish to add a literal tag or bit of metadata that you wish to transform after other processing as a final step.
+   * To do so, you can provide a PostProcessor function and it will be run automatically for you when you call `join()` later on.
+   */
+  addPostProcessor = (postProcessor: PostProcessor) => {
+    this.postProcessors = [...this.postProcessors, postProcessor];
+  };
+}

package/src/helpers/{form-data.js → form-data.ts}

@@ -26,35 +26,24 @@
  * Extracted from https://github.com/node-fetch/node-fetch/blob/64c5c296a0250b852010746c76144cb9e14698d9/src/utils/form-data.js
  */
 
+import type FormData from 'form-data';
+
 const carriage = '\r\n';
 const dashes = '-'.repeat(2);
 
 const NAME = Symbol.toStringTag;
 
-const isBlob = object => {
-  return (
-    typeof object === 'object' &&
-    typeof object.arrayBuffer === 'function' &&
-    typeof object.type === 'string' &&
-    typeof object.stream === 'function' &&
-    typeof object.constructor === 'function' &&
-    /^(Blob|File)$/.test(object[NAME])
-  );
-};
+export const isBlob = (object: any) =>
+  typeof object === 'object' &&
+  typeof object.arrayBuffer === 'function' &&
+  typeof object.type === 'string' &&
+  typeof object.stream === 'function' &&
+  typeof object.constructor === 'function' &&
+  /^(Blob|File)$/.test(object[NAME]);
 
-/**
- * @param {string} boundary
- */
-const getFooter = boundary => `${dashes}${boundary}${dashes}${carriage.repeat(2)}`;
+const getFooter = (boundary: string) => `${dashes}${boundary}${dashes}${carriage.repeat(2)}`;
 
-/**
- * @param {string} boundary
- * @param {string} name
- * @param {*} field
- *
- * @return {string}
- */
-function getHeader(boundary, name, field) {
+const getHeader = (boundary: string, name: string, field: { name: string; type: string }) => {
   let header = '';
 
   header += `${dashes}${boundary}${carriage}`;
@@ -66,28 +55,10 @@ function getHeader(boundary, name, field) {
   }
 
   return `${header}${carriage.repeat(2)}`;
-}
-
-/**
- * @return {string}
- */
-module.exports.getBoundary = () => {
-  // This generates a 50 character boundary similar to those used by Firefox.
-  // They are optimized for boyer-moore parsing.
-  let boundary = '--------------------------';
-  // eslint-disable-next-line no-plusplus
-  for (let i = 0; i < 24; i++) {
-    boundary += Math.floor(Math.random() * 10).toString(16);
-  }
-
-  return boundary;
 };
 
-/**
- * @param {FormData} form
- * @param {string} boundary
- */
-module.exports.formDataIterator = function* (form, boundary) {
+export const formDataIterator = function* (form: FormData, boundary: string) {
+  // @ts-expect-error not sure how this ever worked
   // eslint-disable-next-line no-restricted-syntax
   for (const [name, value] of form) {
     yield getHeader(boundary, name, value);
@@ -103,5 +74,3 @@ module.exports.formDataIterator = function* (form, boundary) {
 
   yield getFooter(boundary);
 };
-
-module.exports.isBlob = isBlob;

package/src/helpers/har-validator.ts

@@ -0,0 +1,35 @@
+import type { ErrorObject } from 'ajv';
+import type { Request } from 'har-format';
+import Ajv from 'ajv';
+import * as schema from 'har-schema';
+
+export class HARError extends Error {
+  name = 'HARError';
+
+  message = 'validation failed';
+
+  errors: ErrorObject[] = [];
+
+  constructor(errors: ErrorObject[]) {
+    super();
+    this.errors = errors;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+const ajv = new Ajv({
+  allErrors: true,
+});
+ajv.addSchema(schema);
+
+export const validateHarRequest = (request: any): request is Request => {
+  const validate = ajv.getSchema('request.json');
+  if (!validate) {
+    throw new Error('failed to find HAR request schema');
+  }
+  const valid = validate(request);
+  if (!valid && validate.errors) {
+    throw new HARError(validate.errors);
+  }
+  return true;
+};

package/src/helpers/headers.test.ts

@@ -0,0 +1,35 @@
+import { getHeader, getHeaderName, hasHeader } from './headers';
+
+const headers = {
+  'Content-Type': 'multipart/form-data; boundary=---011000010111000001101001',
+  accept: 'application/json',
+};
+
+describe('headers', () => {
+  describe('getHeader', () => {
+    it('should get a header', () => {
+      expect(getHeader(headers, 'content-type')).toBe('multipart/form-data; boundary=---011000010111000001101001');
+      expect(getHeader(headers, 'content-TYPE')).toBe('multipart/form-data; boundary=---011000010111000001101001');
+      expect(getHeader(headers, 'Accept')).toBe('application/json');
+      expect(getHeader(headers, 'authorization')).toBeUndefined();
+    });
+  });
+
+  describe('getHeaderName', () => {
+    it('should get a header name', () => {
+      expect(getHeaderName(headers, 'content-type')).toBe('Content-Type');
+      expect(getHeaderName(headers, 'content-TYPE')).toBe('Content-Type');
+      expect(getHeaderName(headers, 'Accept')).toBe('accept');
+      expect(getHeaderName(headers, 'authorization')).toBeUndefined();
+    });
+  });
+
+  describe('hasHeader', () => {
+    it('should return if a header is present', () => {
+      expect(hasHeader(headers, 'content-type')).toBe(true);
+      expect(hasHeader(headers, 'content-TYPE')).toBe(true);
+      expect(hasHeader(headers, 'Accept')).toBe(true);
+      expect(hasHeader(headers, 'authorization')).toBe(false);
+    });
+  });
+});

package/src/helpers/headers.ts

@@ -0,0 +1,31 @@
+type Headers<T> = Record<string, T>;
+
+/**
+ * Given a headers object retrieve a specific header out of it via a case-insensitive key.
+ */
+export const getHeaderName = <T>(headers: Headers<T>, name: string) =>
+  Object.keys(headers).find(header => header.toLowerCase() === name.toLowerCase());
+
+/**
+ * Given a headers object retrieve the contents of a header out of it via a case-insensitive key.
+ */
+export const getHeader = <T>(headers: Headers<T>, name: string) => {
+  const headerName = getHeaderName(headers, name);
+  if (!headerName) {
+    return undefined;
+  }
+  return headers[headerName];
+};
+
+/**
+ * Determine if a given case-insensitive header exists within a header object.
+ */
+export const hasHeader = <T>(headers: Headers<T>, name: string) => Boolean(getHeaderName(headers, name));
+
+/**
+ * Determines if a given MIME type is JSON, or a variant of such.
+ */
+export const isMimeTypeJSON = (mimeType: string) =>
+  ['application/json', 'application/x-json', 'text/json', 'text/x-json', '+json'].some(
+    type => mimeType.indexOf(type) > -1
+  );

package/src/helpers/reducer.test.ts

@@ -0,0 +1,27 @@
+import { reducer } from './reducer';
+
+describe('reducer', () => {
+  it('should convert array object pair to key-value object', () => {
+    const query = [
+      { name: 'key', value: 'value' },
+      { name: 'foo', value: 'bar' },
+    ];
+
+    const result = query.reduce(reducer, {});
+
+    expect(result).toMatchObject({ key: 'value', foo: 'bar' });
+  });
+
+  it('should convert multi-dimensional arrays to key=[array] object', () => {
+    const query = [
+      { name: 'key', value: 'value' },
+      { name: 'foo', value: 'bar1' },
+      { name: 'foo', value: 'bar2' },
+      { name: 'foo', value: 'bar3' },
+    ];
+
+    const result = query.reduce(reducer, {});
+
+    expect(result).toMatchObject({ key: 'value', foo: ['bar1', 'bar2', 'bar3'] });
+  });
+});

package/src/helpers/reducer.ts

@@ -0,0 +1,19 @@
+export type ReducedHelperObject = Record<string, string[] | string>;
+
+export const reducer = <T extends { name: string; value: string }>(accumulator: ReducedHelperObject, pair: T) => {
+  const currentValue = accumulator[pair.name];
+  if (currentValue === undefined) {
+    accumulator[pair.name] = pair.value;
+    return accumulator;
+  }
+
+  // If we already have it as array just push the value
+  if (Array.isArray(currentValue)) {
+    currentValue.push(pair.value);
+    return accumulator;
+  }
+
+  // convert to array since now we have more than one value for this key
+  accumulator[pair.name] = [currentValue, pair.value];
+  return accumulator;
+};

package/src/helpers/shell.ts

@@ -0,0 +1,18 @@
+/**
+ * Use 'strong quoting' using single quotes so that we only need to deal with nested single quote characters.
+ * see: http://wiki.bash-hackers.org/syntax/quoting#strong_quoting
+ */
+export const quote = (value = '') => {
+  const safe = /^[a-z0-9-_/.@%^=:]+$/i;
+
+  const isShellSafe = safe.test(value);
+
+  if (isShellSafe) {
+    return value;
+  }
+
+  // if the value is not shell safe, then quote it
+  return `'${value.replace(/'/g, "'\\''")}'`;
+};
+
+export const escape = (value: string) => value.replace(/\r/g, '\\r').replace(/\n/g, '\\n');

package/src/helpers/utils.test.ts

@@ -0,0 +1,19 @@
+import { availableTargets, extname } from './utils';
+
+describe('availableTargets', () => {
+  it('returns all available targets', () => {
+    expect(availableTargets()).toMatchSnapshot();
+  });
+});
+
+describe('extname', () => {
+  it('returns the correct extension', () => {
+    expect(extname('c')).toBe('.c');
+    expect(extname('clojure')).toBe('.clj');
+  });
+
+  it('returns empty string if the extension is not found', () => {
+    // @ts-expect-error intentionally incorrect
+    expect(extname('ziltoid')).toBe('');
+  });
+});

package/src/helpers/utils.ts

@@ -0,0 +1,16 @@
+import type { ClientInfo, TargetId, TargetInfo } from '../targets/targets';
+import { targets } from '../targets/targets';
+
+export interface AvailableTarget extends TargetInfo {
+  clients: ClientInfo[];
+}
+
+export const availableTargets = () =>
+  Object.keys(targets).map<AvailableTarget>(targetId => ({
+    ...targets[targetId as TargetId].info,
+    clients: Object.keys(targets[targetId as TargetId].clientsById).map(
+      clientId => targets[targetId as TargetId].clientsById[clientId].info
+    ),
+  }));
+
+export const extname = (targetId: TargetId) => targets[targetId]?.info.extname || '';

package/src/index.test.ts

@@ -0,0 +1,221 @@
+import type { Request } from '.';
+import { mimetypes } from './fixtures/mimetypes';
+import headers from './fixtures/requests/headers';
+import query from './fixtures/requests/query';
+import short from './fixtures/requests/short';
+import { HTTPSnippet } from '.';
+
+describe('HTTPSnippet', () => {
+  it('should return false if no matching target', () => {
+    const snippet = new HTTPSnippet(short.log.entries[0].request as Request);
+    // @ts-expect-error intentionally incorrect
+    const result = snippet.convert(null);
+
+    expect(result).toBe(false);
+  });
+
+  it('should fail validation for non-HAR inputs', () => {
+    expect.assertions(1);
+
+    // @ts-expect-error intentionally incorrect
+    const attempt = () => new HTTPSnippet({ ziltoid: 'the omniscient' });
+
+    expect(attempt).toThrow('validation failed');
+  });
+
+  it('should parse HAR file with multiple entries', () => {
+    const snippet = new HTTPSnippet({
+      log: {
+        version: '1.2',
+        creator: {
+          name: 'HTTPSnippet',
+          version: '1.0.0',
+        },
+        entries: [
+          {
+            request: {
+              method: 'GET',
+              url: 'https://httpbin.org/anything',
+            },
+          },
+          {
+            request: {
+              method: 'POST',
+              url: 'https://httpbin.org/anything',
+            },
+          },
+        ],
+      },
+    });
+
+    expect(snippet).toHaveProperty('requests');
+    expect(Array.isArray(snippet.requests)).toBeTruthy();
+    expect(snippet.requests).toHaveLength(2);
+  });
+
+  describe('mimetype conversion', () => {
+    it.each([
+      {
+        input: 'multipart/mixed',
+        expected: 'multipart/form-data',
+      },
+      {
+        input: 'multipart/related',
+        expected: 'multipart/form-data',
+      },
+      {
+        input: 'multipart/alternative',
+        expected: 'multipart/form-data',
+      },
+      {
+        input: 'text/json',
+        expected: 'application/json',
+      },
+      {
+        input: 'text/x-json',
+        expected: 'application/json',
+      },
+      {
+        input: 'application/x-json',
+        expected: 'application/json',
+      },
+      {
+        input: 'invalid-json',
+        expected: 'text/plain',
+      },
+    ] as {
+      input: keyof typeof mimetypes;
+      expected: string;
+    }[])('mimetype conversion of $input to $output', ({ input, expected }) => {
+      const snippet = new HTTPSnippet(mimetypes[input]);
+      const request = snippet.requests[0];
+
+      expect(request.postData.mimeType).toStrictEqual(expected);
+    });
+  });
+
+  it('should set postData.text to empty string when postData.params is undefined in application/x-www-form-urlencoded', () => {
+    const snippet = new HTTPSnippet(mimetypes['application/x-www-form-urlencoded']);
+    const request = snippet.requests[0];
+
+    expect(request.postData.text).toBe('');
+  });
+
+  describe('requestExtras', () => {
+    describe('uriObj', () => {
+      it('should add uriObj', () => {
+        const snippet = new HTTPSnippet(query.log.entries[0].request as Request);
+        const request = snippet.requests[0];
+
+        expect(request.uriObj).toMatchObject({
+          auth: null,
+          hash: null,
+          host: 'httpbin.org',
+          hostname: 'httpbin.org',
+          href: 'https://httpbin.org/anything?key=value',
+          path: '/anything?foo=bar&foo=baz&baz=abc&key=value',
+          pathname: '/anything',
+          port: null,
+          protocol: 'https:',
+          query: {
+            baz: 'abc',
+            key: 'value',
+            foo: ['bar', 'baz'],
+          },
+          search: 'foo=bar&foo=baz&baz=abc&key=value',
+          slashes: true,
+        });
+      });
+
+      it('should fix the `path` property of uriObj to match queryString', () => {
+        const snippet = new HTTPSnippet(query.log.entries[0].request as Request);
+        const request = snippet.requests[0];
+
+        expect(request.uriObj.path).toBe('/anything?foo=bar&foo=baz&baz=abc&key=value');
+      });
+    });
+
+    describe('queryObj', () => {
+      it('should add queryObj', () => {
+        const snippet = new HTTPSnippet(query.log.entries[0].request as Request);
+        const request = snippet.requests[0];
+
+        expect(request.queryObj).toMatchObject({ baz: 'abc', key: 'value', foo: ['bar', 'baz'] });
+      });
+    });
+
+    describe('headersObj', () => {
+      it('should add headersObj', () => {
+        const snippet = new HTTPSnippet(headers.log.entries[0].request as Request);
+        const request = snippet.requests[0];
+
+        expect(request.headersObj).toMatchObject({
+          accept: 'application/json',
+          'x-foo': 'Bar',
+        });
+      });
+
+      it('should add headersObj to source object case insensitive when HTTP/1.0', () => {
+        const snippet = new HTTPSnippet({
+          ...headers.log.entries[0].request,
+          httpVersion: 'HTTP/1.1',
+          headers: [
+            ...headers.log.entries[0].request.headers,
+            {
+              name: 'Kong-Admin-Token',
+              value: 'Ziltoid The Omniscient',
+            },
+          ],
+        } as Request);
+
+        const request = snippet.requests[0];
+
+        expect(request.headersObj).toMatchObject({
+          'Kong-Admin-Token': 'Ziltoid The Omniscient',
+          accept: 'application/json',
+          'x-foo': 'Bar',
+        });
+      });
+
+      it('should add headersObj to source object lowercased when HTTP/2.x', () => {
+        const snippet = new HTTPSnippet({
+          ...headers.log.entries[0].request,
+          httpVersion: 'HTTP/2',
+          headers: [
+            ...headers.log.entries[0].request.headers,
+            {
+              name: 'Kong-Admin-Token',
+              value: 'Ziltoid The Omniscient',
+            },
+          ],
+        } as Request);
+
+        const request = snippet.requests[0];
+
+        expect(request.headersObj).toMatchObject({
+          'kong-admin-token': 'Ziltoid The Omniscient',
+          accept: 'application/json',
+          'x-foo': 'Bar',
+        });
+      });
+    });
+
+    describe('url', () => {
+      it('should modify the original url to strip query string', () => {
+        const snippet = new HTTPSnippet(query.log.entries[0].request as Request);
+        const request = snippet.requests[0];
+
+        expect(request.url).toBe('https://httpbin.org/anything');
+      });
+    });
+
+    describe('fullUrl', () => {
+      it('adds fullURL', () => {
+        const snippet = new HTTPSnippet(query.log.entries[0].request as Request);
+        const request = snippet.requests[0];
+
+        expect(request.fullUrl).toBe('https://httpbin.org/anything?foo=bar&foo=baz&baz=abc&key=value');
+      });
+    });
+  });
+});