refactor: RequestStore now determines valid requests. Refactored tests and other code to accommodate. Ensured validation is fully synchronous.

Author: AndrewWalsh

LICENSE.txt

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Andrew Walsh
+Copyright (c) 2024 Andrew Walsh
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

src/lib/RequestStore.test.ts

@@ -17,12 +17,21 @@ vi.mock("./store-helpers/persist-options", async () => {
 const host = "test.com";
 const base = `https://${host}`;
 const POST = "POST";
+const testKey = "test";
+const testStrObj = { [testKey]: "string" };
+const contentStrTest = JSON.stringify(testStrObj);
+const testIntObj = { [testKey]: 1 };
+const contentIntTest = JSON.stringify(testIntObj);
+const testNullObj = { [testKey]: null };
+const contentNullTest = JSON.stringify(testNullObj);
+const testBoolObj = { [testKey]: true };
+const contentBoolTest = JSON.stringify(testBoolObj);
 
 const getResBodyJSONTypes = (
   store: RequestStore,
   host: string,
   path: string,
-  propName = "foo",
+  propName = testKey
 ) => {
   const match = store.get()[host]?.lookup(path);
   if (!match) throw new Error("Could not match path");
@@ -37,10 +46,10 @@ it("parameterises and merges paths", () => {
   const req1 = createSimpleRequest(`${base}/1/2/a`);
   const req2 = createSimpleRequest(`${base}/1/2/b`);
   const req3 = createSimpleRequest(`${base}/1/2/c`);
-  store.insert(req1, { foo: "bar" });
-  store.insert(req2, { foo: 1 });
+  store.insert(req1, contentStrTest);
+  store.insert(req2, contentIntTest);
   store.parameterise(2, "/1/2/a", host);
-  store.insert(req3, { foo: null });
+  store.insert(req3, contentNullTest);
   store.parameterise(1, "/1/2/:param2", host);
   const properties = getResBodyJSONTypes(store, host, "/1/zzz/asbds");
   expect(properties).toContain("string");
@@ -52,7 +61,7 @@ it("parameterises and merges paths", () => {
 it("inserts data and can retrieve it", () => {
   const store = new RequestStore();
   const req = createSimpleRequest(`${base}/1/2/a`);
-  store.insert(req, { foo: 1 });
+  store.insert(req, contentIntTest);
   const properties = getResBodyJSONTypes(store, host, "/1/2/a");
   expect(properties).toBe("integer");
 });
@@ -65,14 +74,14 @@ it("sets leafMap correctly after multiple add and parameterise operations", () =
   const req4 = createSimpleRequest(`${base}/1/2/c`);
   const req5 = createSimpleRequest(`${base}/dynamicPath/2/a`);
   const req6 = createSimpleRequest(`${base}/dynamicPath/2/b`);
-  store.insert(req1, { foo: "bar" });
-  store.insert(req2, { foo: "bar" });
-  store.insert(req3, { foo: 1 });
+  store.insert(req1, contentStrTest);
+  store.insert(req2, contentStrTest);
+  store.insert(req3, contentIntTest);
   store.parameterise(2, "/1/2/a", host);
-  store.insert(req4, { foo: null });
+  store.insert(req4, contentNullTest);
   store.parameterise(1, "/1/2/:param2", host);
-  store.insert(req5, { foo: "bar" });
-  store.insert(req6, { foo: 1 });
+  store.insert(req5, contentStrTest);
+  store.insert(req6, contentIntTest);
   store.parameterise(2, "/dynamicPath/2/b", host);
   store.parameterise(1, "/dynamicPath/2/:param2", host);
   const expected = {
@@ -94,7 +103,7 @@ it("sets leafMap correctly after multiple add and parameterise operations", () =
     "string",
   ]);
   expect(getResBodyJSONTypes(store, host, "/staticPath/2/3/4/5")).toBe(
-    "string",
+    "string"
   );
 });
 
@@ -104,10 +113,10 @@ it("sets leafMap correctly after many parameterise operations", () => {
   const req2 = createSimpleRequest(`${base}/1/2/3/z/b`);
   const req3 = createSimpleRequest(`${base}/1/x/y/z/b`);
   const req4 = createSimpleRequest(`${base}/1/2/b`);
-  store.insert(req1, { foo: "bar" });
-  store.insert(req2, { foo: null });
-  store.insert(req3, { foo: 1 });
-  store.insert(req4, { foo: true });
+  store.insert(req1, contentStrTest);
+  store.insert(req2, contentNullTest);
+  store.insert(req3, contentIntTest);
+  store.insert(req4, contentBoolTest);
   store.parameterise(4, "/1/2/3/4/a", host);
   store.parameterise(3, "/1/x/y/z/b", host);
   store.parameterise(3, "/1/2/3/4/:param4", host);
@@ -133,9 +142,9 @@ it("collapses into a single route when paramaterised", () => {
   const req1 = createSimpleRequest(`${base}/1/2/3/4/a`);
   const req2 = createSimpleRequest(`${base}/1/2/3/4/b`);
   const req3 = createSimpleRequest(`${base}/1/2/3/4/c`);
-  store.insert(req1, { foo: "bar" });
-  store.insert(req2, { foo: null });
-  store.insert(req3, { foo: 1 });
+  store.insert(req1, contentStrTest);
+  store.insert(req2, contentNullTest);
+  store.insert(req3, contentIntTest);
   store.parameterise(3, "/1/2/3/4/a", host);
   store.parameterise(4, "/1/2/3/:param3/a", host);
   const expected = {
@@ -156,8 +165,8 @@ it("can parameterise paths that are subsets of another path", () => {
   const store = new RequestStore();
   const req1 = createSimpleRequest(`${base}/1/2/a`);
   const req2 = createSimpleRequest(`${base}/1/2`);
-  store.insert(req1, { foo: "bar" });
-  store.insert(req2, { foo: 1 });
+  store.insert(req1, contentStrTest);
+  store.insert(req2, contentIntTest);
   store.parameterise(1, "/1/2", host);
   const expected = {
     [host]: {
@@ -177,10 +186,10 @@ it("can parameterise paths that exist along the same segment", () => {
   const req2 = createSimpleRequest(`${base}/1/2`);
   const req3 = createSimpleRequest(`${base}/1`);
   const req4 = createSimpleRequest(`${base}/1/2/3/4`);
-  store.insert(req1, { foo: "bar" });
-  store.insert(req2, { foo: 1 });
-  store.insert(req3, { foo: null });
-  store.insert(req4, { foo: null });
+  store.insert(req1, contentStrTest);
+  store.insert(req2, contentIntTest);
+  store.insert(req3, contentNullTest);
+  store.insert(req4, contentNullTest);
   store.parameterise(1, "/1/2/a", host);
   // Bug happens below. When /1/2 is parameterised, router.remove removes /1/2/3/4
   store.parameterise(1, "/1/2", host);
@@ -202,11 +211,11 @@ it("parameterising a path catches future requests to the same path", () => {
   const store = new RequestStore();
   const req1 = createSimpleRequest(`${base}/1/2/a`);
   const req2 = createSimpleRequest(`${base}/1/2/b`);
-  store.insert(req1, { foo: "bar" });
-  store.insert(req2, { foo: "bar" });
+  store.insert(req1, contentStrTest);
+  store.insert(req2, contentStrTest);
   store.parameterise(1, "/1/2/a", host);
-  store.insert(req1, { foo: 1 });
-  store.insert(req2, { foo: 1 });
+  store.insert(req1, contentIntTest);
+  store.insert(req2, contentIntTest);
   const expected = {
     [host]: {
       "/1/:param1/a": expect.any(Object),
@@ -222,12 +231,12 @@ it("parameterisation works after export and import", () => {
   const req = createSimpleRequest(`${base}/1/2/a`);
   const options = { enableMoreInfo: true };
   store.options(options);
-  store.insert(req, { foo: 1 });
+  store.insert(req, contentIntTest);
   store.parameterise(2, "/1/2/a", host);
   const exported = store.export();
   store.clear();
   store.import(exported);
-  store.insert(req, { foo: 1 });
+  store.insert(req, contentIntTest);
   const expectedLeafMap = {
     [host]: {
       "/1/2/:param2": expect.any(Object),

src/lib/RequestStore.ts

@@ -9,7 +9,9 @@ import {
 import { omit, unset } from "lodash";
 import leafMapToEndpoints from "./leafmap-to-endpoints";
 import stringify from "json-stable-stringify";
-import type { Entry } from 'har-format';
+import type { Entry } from "har-format";
+import decodeUriComponent from "decode-uri-component";
+import { isValidRequest, parseJSON } from "../utils/helpers";
 
 export type Options = {
   // Includes additional data such as response samples
@@ -27,8 +29,8 @@ export default class RequestStore {
   private storeOptions: Options;
 
   constructor(storeOptions = persistOptions.get()) {
-    this.leafMap = {}; // persist.get() || {};
-    this.store = {}; // leafMapToRouterMap(this.leafMap);
+    this.leafMap = {};
+    this.store = {};
     this.disabledHosts = new Set();
     this.storeOptions = storeOptions;
   }
@@ -63,7 +65,6 @@ export default class RequestStore {
     this.store = {};
     this.leafMap = {};
     this.disabledHosts = new Set();
-    // persist.clear();
   }
 
   public endpoints(): Array<Endpoint> {
@@ -84,25 +85,25 @@ export default class RequestStore {
     return Object.keys(this.store);
   }
 
-  public insert(
-    harRequest: Entry,
-    responseBody: JSONType
-  ) {
+  public insert(harRequest: Entry, content: string): boolean {
+    if (!isValidRequest(harRequest, content)) return false;
+    harRequest.request.url = decodeUriComponent(harRequest.request.url);
+    const responseBody: JSONType = parseJSON(content);
     const result = upsert({
       harRequest,
       responseBody,
       store: this.store,
       options: this.storeOptions,
     });
-    if (!result) return;
+    if (!result) return false;
     const { insertedPath, insertedLeaf, insertedHost } = result;
     insertLeafMap({
       leafMap: this.leafMap,
       host: insertedHost,
       leaf: insertedLeaf,
       path: insertedPath,
     });
-    // persist.set(this.leafMap);
+    return true;
   }
 
   public parameterise(index: number, path: string, host: string): void {
@@ -117,7 +118,6 @@ export default class RequestStore {
       leaf: insertedLeaf,
       path: insertedPath,
     });
-    // persist.set(this.leafMap);
   }
 
   public setDisabledHosts(disabledHosts: Set<string>): void {

src/lib/endpoints-to-oai31.test.ts

@@ -13,14 +13,17 @@ import RequestStore, { Options } from "./RequestStore.js";
 import { defaultOptions } from "./store-helpers/persist-options.js";
 import { AuthType } from "../utils/types.js";
 
+const testStrObj = { test: "string" };
+const contentStrTest = JSON.stringify(testStrObj);
+
 const createRequestStoreWithDefaults = () => {
   const store = new RequestStore();
   const req1 = cloneDeep(postJson);
   req1.request.url = "https://example.com/api/v1/1a";
   const req2 = cloneDeep(postJson);
   req2.request.url = "https://example.com/api/v1/2 . ";
-  store.insert(req1, { test: "string" });
-  store.insert(req2, { test: "string" });
+  store.insert(req1, contentStrTest);
+  store.insert(req2, contentStrTest);
   return store;
 };
 
@@ -38,8 +41,8 @@ it("handles multiple status codes in responses", () => {
   const req1 = cloneDeep(postJson);
   const req2 = cloneDeep(postJson);
   req2.response.status = 304;
-  store.insert(req1, { test: "string" });
-  store.insert(req2, { test: "string" });
+  store.insert(req1, contentStrTest);
+  store.insert(req2, contentStrTest);
   const endpoints = store.endpoints();
   const oai31 = endpointsToOAI31(endpoints, options);
   const result = oai31.rootDoc.paths?.["/v1/track"].post?.responses;
@@ -50,7 +53,7 @@ it("handles multiple status codes in responses", () => {
 it("sets most recent request when enabled", () => {
   const options: Options = { enableMoreInfo: true };
   const store = new RequestStore(options);
-  store.insert(postJson, { test: "string" });
+  store.insert(postJson, contentStrTest);
   const endpoints = store.endpoints();
   const oai31 = endpointsToOAI31(endpoints, options);
   const result =
@@ -64,19 +67,19 @@ it("sets most recent request when enabled", () => {
 it("sets most recent response when enabled", () => {
   const options: Options = { enableMoreInfo: true };
   const store = new RequestStore(options);
-  store.insert(postJson, { test: "string" });
+  store.insert(postJson, contentStrTest);
   const endpoints = store.endpoints();
   const oai31 = endpointsToOAI31(endpoints, options);
   const result =
     oai31.rootDoc.paths?.["/v1/track"].post?.responses["200"].content[
       "application/json"
     ].example;
-  expect(result).toEqual({ test: "string" });
+  expect(result).toEqual(testStrObj);
 });
 
 it("sets bearer auth security schema when available", () => {
   const store = new RequestStore();
-  store.insert(bearer, { test: "string" });
+  store.insert(bearer, contentStrTest);
   const endpoints = store.endpoints();
   const oai31 = endpointsToOAI31(endpoints, defaultOptions);
   expect(oai31.rootDoc.components?.securitySchemes).toEqual({
@@ -95,7 +98,7 @@ it("sets bearer auth security schema when available", () => {
 
 it("sets basic auth security schema when available", () => {
   const store = new RequestStore();
-  store.insert(basic, { test: "string" });
+  store.insert(basic, contentStrTest);
   const endpoints = store.endpoints();
   const oai31 = endpointsToOAI31(endpoints, defaultOptions);
   expect(oai31.rootDoc.components?.securitySchemes).toEqual({
@@ -114,7 +117,7 @@ it("sets basic auth security schema when available", () => {
 
 it("sets digest auth security schema when available", () => {
   const store = new RequestStore();
-  store.insert(digest, { test: "string" });
+  store.insert(digest, contentStrTest);
   const endpoints = store.endpoints();
   const oai31 = endpointsToOAI31(endpoints, defaultOptions);
   expect(oai31.rootDoc.components?.securitySchemes).toEqual({
@@ -133,7 +136,7 @@ it("sets digest auth security schema when available", () => {
 
 it("sets api keys from headers", () => {
   const store = new RequestStore();
-  store.insert(apikey, { test: "string" });
+  store.insert(apikey, contentStrTest);
   const endpoints = store.endpoints();
   const oai31 = endpointsToOAI31(endpoints, defaultOptions);
   expect(oai31.rootDoc.components?.securitySchemes).toEqual({

src/lib/store-helpers/authentication-http.ts

@@ -24,10 +24,7 @@ export interface DigestAuthHeader extends HTTPAuth {
   in: "header";
 }
 
-export type HTTP =
-  | DigestAuthHeader
-  | BasicAuthHeader
-  | BearerAuthHeader;
+export type HTTP = DigestAuthHeader | BasicAuthHeader | BearerAuthHeader;
 
 export const parseHTTPAuthHeader = (value: string): HTTP | undefined => {
   const authType = getAuthType(value);