sdk: memoize OPA fallback decision

Signed-off-by: Stephan Renatus <[email protected]>

Author: srenatus

src/opaclient.ts

@@ -61,6 +61,7 @@ export interface BatchRequestOptions<Res> extends RequestOptions<Res> {
  */
 export class OPAClient {
   private opa: Opa;
+  private opaFallback: boolean = false;
 
   /** Create a new `OPA` instance.
    * @param serverURL - The OPA URL, e.g. `https://opa.internal.corp:8443/`.
@@ -167,59 +168,30 @@ export class OPAClient {
     );
     let res: BatchMixedResults | BatchSuccessfulPolicyEvaluation | undefined;
 
-    try {
-      const resp = await this.opa.executeBatchPolicyWithInput(
-        { path, requestBody: { inputs: inps } },
-        opts,
-      );
-
-      res = resp.batchMixedResults || resp.batchSuccessfulPolicyEvaluation;
-    } catch (err) {
-      // TODO(sr): memoize fallback
-      if (
-        err instanceof SDKError &&
-        err.httpMeta.response.status == 404 &&
-        opts?.fallback
-      ) {
-        // run a sequence of evaluatePolicyWithInput() instead, via Promise.all/Promise.allSettled
-        let items: [string, ServerError | SuccessfulPolicyResponse][];
-        const inputs = Object.values(inps);
-        const keys = Object.keys(inps);
-        const ps = inputs.map((input) =>
-          this.opa
-            .executePolicyWithInput({ path, requestBody: { input } })
-            .then(({ successfulPolicyResponse: res }) => res),
+    if (this.opaFallback && opts?.fallback) {
+      // memoized fallback: we have hit a 404 here before
+      const responses = await this.fallbackBatch(path, inps, opts);
+      res = { responses };
+    } else {
+      try {
+        const resp = await this.opa.executeBatchPolicyWithInput(
+          { path, requestBody: { inputs: inps } },
+          opts,
         );
-        if (opts?.rejectMixed) {
-          items = await Promise.all(ps).then((results) =>
-            results.map((result, i) => {
-              if (!result) throw `no result in API response`;
-              return [
-                keys[i] as string, // can't be undefined
-                result,
-              ];
-            }),
-          );
+
+        res = resp.batchMixedResults || resp.batchSuccessfulPolicyEvaluation;
+      } catch (err) {
+        if (
+          err instanceof SDKError &&
+          err.httpMeta.response.status == 404 &&
+          opts?.fallback
+        ) {
+          this.opaFallback = true;
+          const responses = await this.fallbackBatch(path, inps, opts);
+          res = { responses };
         } else {
-          const settled = await Promise.allSettled(ps).then((results) => {
-            return results.map((res, i) => {
-              if (res.status === "rejected") {
-                return [
-                  keys[i],
-                  {
-                    ...(res.reason as ServerError_).data$,
-                    httpStatusCode: "500",
-                  },
-                ] as [string, ServerError];
-              }
-              return [keys[i], res.value] as [string, SuccessfulPolicyResponse];
-            });
-          });
-          items = settled;
+          throw err;
         }
-        res = { responses: Object.fromEntries(items) };
-      } else {
-        throw err;
       }
     }
 
@@ -231,6 +203,49 @@ export class OPAClient {
     }
     return Object.fromEntries(entries);
   }
+
+  // run a sequence of evaluatePolicyWithInput(), via Promise.all/Promise.allSettled
+  async fallbackBatch<Res>(
+    path: string,
+    inputs: { [k: string]: Input },
+    opts?: BatchRequestOptions<Res>,
+  ): Promise<{ [k: string]: ServerError | SuccessfulPolicyResponse }> {
+    let items: [string, ServerError | SuccessfulPolicyResponse][];
+    const keys = Object.keys(inputs);
+    const ps = Object.values(inputs).map((input) =>
+      this.opa
+        .executePolicyWithInput({ path, requestBody: { input } })
+        .then(({ successfulPolicyResponse: res }) => res),
+    );
+    if (opts?.rejectMixed) {
+      items = await Promise.all(ps).then((results) =>
+        results.map((result, i) => {
+          if (!result) throw `no result in API response`;
+          return [
+            keys[i] as string, // can't be undefined
+            result,
+          ];
+        }),
+      );
+    } else {
+      const settled = await Promise.allSettled(ps).then((results) => {
+        return results.map((res, i) => {
+          if (res.status === "rejected") {
+            return [
+              keys[i],
+              {
+                ...(res.reason as ServerError_).data$,
+                httpStatusCode: "500",
+              },
+            ] as [string, ServerError];
+          }
+          return [keys[i], res.value] as [string, SuccessfulPolicyResponse];
+        });
+      });
+      items = settled;
+    }
+    return Object.fromEntries(items);
+  }
 }
 
 function processResult<Res>(