Merge pull request #17 from Fullscript/pii-data-token

benaiahbarango · web-flow · commit fa515aa16d9f · 2022-10-12T08:41:08.000-04:00
Tokenize patient data if provided
diff --git a/src/feature/feature.spec.ts b/src/feature/feature.spec.ts
@@ -72,30 +72,30 @@ describe("feature", () => {
 
   describe("mount", () => {
     it("calls the createIframe function when mount is called", () => {
-      return import("./feature").then(({ getFeature }) => {
+      return import("./feature").then(async ({ getFeature }) => {
         // hoisting issue with jest.mocks()
         const feature = getFeature(
           mockFeatureType,
           mockFeatureOptions,
           mockFullscriptOptions,
           dispatcher
         );
-        feature.mount("someid");
+        await feature.mount("someid");
 
         expect(mockCreateIframe).toBeCalled();
       });
     });
 
     it("appends child to the mountPoint when mount is called", () => {
-      return import("./feature").then(({ getFeature }) => {
+      return import("./feature").then(async ({ getFeature }) => {
         mockMountPoint.appendChild = jest.fn();
         const feature = getFeature(
           mockFeatureType,
           mockFeatureOptions,
           mockFullscriptOptions,
           dispatcher
         );
-        feature.mount("someid");
+        await feature.mount("someid");
 
         expect(mockMountPoint.appendChild).toBeCalled();
       });
@@ -105,7 +105,7 @@ describe("feature", () => {
   it("does not return an iframe and throws an error if the provided elementId is undefined", () => {
     document.getElementById = jest.fn(() => null);
 
-    return import("./feature").then(({ getFeature }) => {
+    return import("./feature").then(async ({ getFeature }) => {
       mockMountPoint.appendChild = jest.fn();
       const feature = getFeature(
         mockFeatureType,
@@ -116,9 +116,7 @@ describe("feature", () => {
 
       expect(mockMountPoint.appendChild).not.toBeCalled();
 
-      expect(() => {
-        feature.mount("blah");
-      }).toThrow(
+      await expect(feature.mount("blah")).rejects.toThrow(
         "Could not find the mount point for the iframe. Please check that the elementId provided in .mount() matches the one that's used in the DOM"
       );
     });
diff --git a/src/feature/feature.ts b/src/feature/feature.ts
@@ -18,10 +18,10 @@ const getFeature = <F extends FeatureType>(
 ): Feature => {
   let mountPoint: HTMLElement;
   const frameId = uuidv4();
-  const url = getFeatureURL(featureType, featureOptions, fullscriptOptions, frameId);
 
   // TODO: If we can only mount a feature once, throw an error if attempting to mount a second time
-  const mount = (elementId: string) => {
+  const mount = async (elementId: string) => {
+    const url = await getFeatureURL(featureType, featureOptions, fullscriptOptions, frameId);
     mountPoint = document.getElementById(elementId);
     validateMountPoint(mountPoint);
     const iframe = createIframe(url);
diff --git a/src/feature/featureType.ts b/src/feature/featureType.ts
@@ -24,7 +24,7 @@ type FeatureOptions<F extends FeatureType> = F extends "treatmentPlan"
   : Record<any, never>;
 
 interface Feature {
-  mount: (elementId: string) => void;
+  mount: (elementId: string) => Promise<void>;
   unmount: () => void;
   on: EventListenerFunction;
   off: EventListenerFunction;
diff --git a/src/feature/featureUtil.spec.ts b/src/feature/featureUtil.spec.ts
@@ -7,6 +7,13 @@ describe("getFeatureUrl", () => {
   let mockFeatureOptions: FeatureOptions<"treatmentPlan">;
   let mockFullscriptOptions: FullscriptOptions;
   let mockFrameId: string;
+  const mockDataToken = "random+data_token";
+
+  window.fetch = jest.fn(() =>
+    Promise.resolve({
+      json: () => Promise.resolve({ data_token: mockDataToken }),
+    })
+  ) as jest.Mock;
 
   beforeEach(() => {
     mockFeatureOptions = {
@@ -24,35 +31,39 @@ describe("getFeatureUrl", () => {
     mockFrameId = "uuid";
   });
 
-  it("returns the proper url", () => {
-    const url = getFeatureURL(
+  it("returns the proper url", async () => {
+    const url = await getFeatureURL(
       "treatmentPlan",
       mockFeatureOptions,
       mockFullscriptOptions,
       mockFrameId
     );
 
     expect(url).toEqual(
-      "https://us-snd.fullscript.io/api/embeddable/session/treatment_plans/new?patient[id]=patientId&secret_token=secretToken&public_key=publicKey&frame_id=uuid&target_origin=http://localhost"
+      `https://us-snd.fullscript.io/api/embeddable/session/treatment_plans/new?data_token=${encodeURIComponent(
+        mockDataToken
+      )}&secret_token=secretToken&public_key=publicKey&frame_id=uuid&target_origin=http://localhost`
     );
   });
 
-  it("returns proper custom url if domain is present", () => {
+  it("returns proper custom url if domain is present", async () => {
     const customDomain = "https://staging.r.fullscript.io";
     mockFullscriptOptions = {
       ...mockFullscriptOptions,
       domain: customDomain,
     };
 
-    const url = getFeatureURL(
+    const url = await getFeatureURL(
       "treatmentPlan",
       mockFeatureOptions,
       mockFullscriptOptions,
       mockFrameId
     );
 
     expect(url).toEqual(
-      `${customDomain}/api/embeddable/session/treatment_plans/new?patient[id]=patientId&secret_token=secretToken&public_key=publicKey&frame_id=uuid&target_origin=http://localhost`
+      `${customDomain}/api/embeddable/session/treatment_plans/new?data_token=${encodeURIComponent(
+        mockDataToken
+      )}&secret_token=secretToken&public_key=publicKey&frame_id=uuid&target_origin=http://localhost`
     );
   });
 });
diff --git a/src/feature/featureUtil.ts b/src/feature/featureUtil.ts
@@ -5,14 +5,19 @@ import { buildQueryString } from "../utils";
 import { FEATURE_PATHS } from "./featurePath";
 import { FeatureType, FeatureOptions } from "./featureType";
 
-const getFeatureURL = <F extends FeatureType>(
+const getFeatureURL = async <F extends FeatureType>(
   featureType: F,
   featureOptions: FeatureOptions<F>,
   fullscriptOptions: FullscriptOptions,
   frameId: string
-): string => {
+): Promise<string> => {
   const { publicKey, env, domain } = fullscriptOptions;
-  const queryString = buildQueryString({ ...featureOptions, publicKey, frameId });
+  const queryString = await buildQueryString({
+    ...featureOptions,
+    fullscriptOptions,
+    publicKey,
+    frameId,
+  });
   validateFeatureType(featureType);
   const fsDomain = domain ?? FULLSCRIPT_DOMAINS[env];
 
diff --git a/src/utils/utils.spec.ts b/src/utils/utils.spec.ts
@@ -5,6 +5,11 @@ describe("utils", () => {
   let mockParams: Params;
   const mockKey = "pupper";
   const mockValue = "nessa";
+  const mockDataToken = "random+data_token";
+  const mockFullscriptOptions = {
+    publicKey: "mockPublicKey",
+    env: "us",
+  };
 
   beforeEach(() => {
     elem = document.createElement("div");
@@ -32,28 +37,66 @@ describe("utils", () => {
   });
 
   describe("buildQueryString", () => {
-    it("returns an empty string if params have no keys", () => {
+    it("returns an empty string if params have no keys", async () => {
       mockParams = {};
-      const builtQueryString = buildQueryString(mockParams);
-      expect(builtQueryString).toHaveLength(0);
+      const builtQueryString = await buildQueryString(mockParams);
+      await expect(builtQueryString).toHaveLength(0);
     });
 
-    it("properly builds a query string with proper key and param values", () => {
-      const builtQueryString = buildQueryString(mockParams);
+    it("properly builds a query string with proper key and param values", async () => {
+      const builtQueryString = await buildQueryString(mockParams);
 
-      expect(builtQueryString).toEqual(`?key=${mockKey}&value=${mockValue}`);
+      await expect(builtQueryString).toEqual(`?key=${mockKey}&value=${mockValue}`);
     });
 
-    it("converts keys into snakecase", () => {
+    it("converts keys into snakecase", async () => {
       mockParams = { fooBar: "foobar" };
-      const builtQueryString = buildQueryString(mockParams);
-      expect(builtQueryString).toEqual(`?foo_bar=${mockParams.fooBar}`);
+      const builtQueryString = await buildQueryString(mockParams);
+      await expect(builtQueryString).toEqual(`?foo_bar=${mockParams.fooBar}`);
     });
 
-    it("accept object params", () => {
+    it("accept object params", async () => {
       mockParams = { something: "else", foo: { bar: "foobar" } };
-      const queryString = buildQueryString(mockParams);
-      expect(queryString).toEqual(`?something=else&foo[bar]=${mockParams.foo.bar}`);
+      const queryString = await buildQueryString(mockParams);
+      await expect(queryString).toEqual(`?something=else&foo[bar]=${mockParams.foo.bar}`);
+    });
+
+    it("properly converts patient info to token", async () => {
+      mockParams = {
+        fooBar: "foobar",
+        patient: { id: "patientId" },
+        fullscriptOptions: mockFullscriptOptions,
+      };
+
+      window.fetch = jest.fn(() =>
+        Promise.resolve({
+          json: () => Promise.resolve({ data_token: mockDataToken }),
+        })
+      ) as jest.Mock;
+
+      const builtQueryString = await buildQueryString(mockParams);
+
+      await expect(builtQueryString).toEqual(
+        `?data_token=${encodeURIComponent(mockDataToken)}&foo_bar=${mockParams.fooBar}`
+      );
+    });
+
+    it("passes null data token if tokenization fails", async () => {
+      mockParams = {
+        fooBar: "foobar",
+        patient: { id: "patientId" },
+        fullscriptOptions: mockFullscriptOptions,
+      };
+
+      window.fetch = jest.fn(() =>
+        Promise.reject({
+          json: () => Promise.resolve({ error: "some error" }),
+        })
+      ) as jest.Mock;
+
+      const builtQueryString = await buildQueryString(mockParams);
+
+      await expect(builtQueryString).toEqual(`?data_token=null&foo_bar=${mockParams.fooBar}`);
     });
   });
 });
diff --git a/src/utils/utils.ts b/src/utils/utils.ts
@@ -1,3 +1,5 @@
+import { FULLSCRIPT_DOMAINS } from "../fullscript";
+
 export type Params = { key: string; value: any } | any;
 
 const removeChildren = (element: HTMLElement): void => {
@@ -13,16 +15,56 @@ const snakeCase = (word: string): string => {
     .join("_");
 };
 
-const buildQueryString = (params: Params): string => {
+const snakeCaseObjectKeys = (obj: any) => {
+  return Object.keys(obj).reduce(
+    (result, key) => ({
+      ...result,
+      [snakeCase(key)]: obj[key],
+    }),
+    {}
+  );
+};
+
+const tokenizeData = async (patientInfo, fullscriptOptions) => {
+  try {
+    const { env, domain } = fullscriptOptions;
+    const fsDomain = domain ?? FULLSCRIPT_DOMAINS[env];
+
+    const tokenizedInfo = await fetch(`${fsDomain}/api/embeddable/tokenize`, {
+      method: "POST",
+      body: JSON.stringify({ data: patientInfo }),
+      headers: { "Content-Type": "application/json" },
+    }).then(res => res.json());
+
+    if (typeof tokenizedInfo.data_token !== "string") throw new Error("Invalid response");
+
+    return tokenizedInfo.data_token;
+  } catch (error) {
+    return null;
+  }
+};
+
+const buildQueryString = async (params: Params): Promise<string> => {
   if (!Object.keys(params) || Object.keys(params).length === 0) return "";
-  return Object.keys(params).reduce((queryString, key) => {
-    let newParam = `${snakeCase(key)}=${params[key]}`;
 
-    if (typeof params[key] !== "string") {
-      newParam = Object.keys(params[key]).reduce(
+  const { patient: patientInfo, fullscriptOptions, ...exposedParams } = params;
+  let startingQueryString = "?";
+
+  if (patientInfo) {
+    const snakeCasePatient = snakeCaseObjectKeys(patientInfo);
+    const dataToken = await tokenizeData(snakeCasePatient, fullscriptOptions);
+
+    startingQueryString += `data_token=${encodeURIComponent(dataToken)}&`;
+  }
+
+  return Object.keys(exposedParams).reduce((queryString, key) => {
+    let newParam = `${snakeCase(key)}=${exposedParams[key]}`;
+
+    if (typeof exposedParams[key] !== "string") {
+      newParam = Object.keys(exposedParams[key]).reduce(
         (objectParams, attribute, currentIndex): string => {
           const objectParam = `${snakeCase(key)}[${snakeCase(attribute)}]=${encodeURIComponent(
-            params[key][attribute]
+            exposedParams[key][attribute]
           )}`;
 
           if (currentIndex === 0) {
@@ -34,12 +76,12 @@ const buildQueryString = (params: Params): string => {
       );
     }
 
-    if (queryString !== "?") {
+    if (queryString !== startingQueryString) {
       newParam = `&${newParam}`;
     }
 
     return `${queryString}${newParam}`;
-  }, "?");
+  }, startingQueryString);
 };
 
 export { removeChildren, buildQueryString };
