challenger preact api

4 files changed, 244 insertions, 18 deletions

diff --git a/packages/web-util/src/context/activity.ts b/packages/web-util/src/context/activity.ts
index 422b25909..3cfd83bda 100644
--- a/packages/web-util/src/context/activity.ts
+++ b/packages/web-util/src/context/activity.ts
@@ -14,7 +14,7 @@
  GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
  */
 
-import { ObservabilityEvent, TalerAuthenticationHttpClient, TalerBankConversionHttpClient, TalerCoreBankHttpClient, TalerMerchantInstanceHttpClient, TalerMerchantManagementHttpClient } from "@gnu-taler/taler-util";
+import { ChallengerHttpClient, ObservabilityEvent, TalerAuthenticationHttpClient, TalerBankConversionHttpClient, TalerCoreBankHttpClient, TalerMerchantInstanceHttpClient, TalerMerchantManagementHttpClient } from "@gnu-taler/taler-util";
 
 type Listener<Event> = (e: Event) => void;
 type Unsuscriber = () => void;
@@ -66,3 +66,7 @@ export interface BankLib {
   auth: (user: string) => TalerAuthenticationHttpClient;
 }
 
+export interface ChallengerLib {
+  bank: ChallengerHttpClient;
+}
+
diff --git a/packages/web-util/src/context/challenger-api.ts b/packages/web-util/src/context/challenger-api.ts
new file mode 100644
index 000000000..960f1db0d
--- /dev/null
+++ b/packages/web-util/src/context/challenger-api.ts
@@ -0,0 +1,209 @@
+/*
+ This file is part of GNU Taler
+ (C) 2022-2024 Taler Systems S.A.
+
+ GNU Taler is free software; you can redistribute it and/or modify it under the
+ terms of the GNU General Public License as published by the Free Software
+ Foundation; either version 3, or (at your option) any later version.
+
+ GNU Taler is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along with
+ GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+import {
+  ChallengerApi,
+  ChallengerHttpClient,
+  LibtoolVersion,
+  ObservabilityEvent,
+  ObservableHttpClientLibrary,
+  TalerError
+} from "@gnu-taler/taler-util";
+import {
+  ComponentChildren,
+  FunctionComponent,
+  VNode,
+  createContext,
+  h,
+} from "preact";
+import { useContext, useEffect, useState } from "preact/hooks";
+import { BrowserFetchHttpLib, ErrorLoading } from "../index.browser.js";
+import {
+  APIClient,
+  ActiviyTracker,
+  ChallengerLib,
+  Subscriber
+} from "./activity.js";
+import { useTranslationContext } from "./translation.js";
+
+/**
+ *
+ * @author Sebastian Javier Marchano (sebasjm)
+ */
+
+export type ChallengerContextType = {
+  url: URL;
+  config: ChallengerApi.ChallengerTermsOfServiceResponse;
+  lib: ChallengerLib;
+  hints: VersionHint[];
+  onActivity: Subscriber<ObservabilityEvent>;
+  cancelRequest: (eventId: string) => void;
+};
+
+// @ts-expect-error default value to undefined, should it be another thing?
+const ChallengerContext = createContext<ChallengerContextType>(undefined);
+
+export const useChallengerApiContext = (): ChallengerContextType =>
+  useContext(ChallengerContext);
+
+enum VersionHint {
+  NONE,
+}
+
+type Evictors = Record<string, never>;
+
+type ConfigResult<T> =
+  | undefined
+  | { type: "ok"; config: T; hints: VersionHint[] }
+  | { type: "incompatible"; result: T; supported: string }
+  | { type: "error"; error: TalerError };
+
+const CONFIG_FAIL_TRY_AGAIN_MS = 5000;
+
+export const ChallengerApiProvider = ({
+  baseUrl,
+  children,
+  frameOnError,
+  evictors = {},
+}: {
+  baseUrl: URL;
+  children: ComponentChildren;
+  evictors?: Evictors;
+  frameOnError: FunctionComponent<{ children: ComponentChildren }>;
+}): VNode => {
+  const [checked, setChecked] =
+    useState<ConfigResult<ChallengerApi.ChallengerTermsOfServiceResponse>>();
+  const { i18n } = useTranslationContext();
+
+  const { getRemoteConfig, VERSION, lib, cancelRequest, onActivity } =
+    buildChallengerApiClient(baseUrl, evictors);
+
+  useEffect(() => {
+    let keepRetrying = true;
+    async function testConfig(): Promise<void> {
+      try {
+        const config = await getRemoteConfig();
+        if (LibtoolVersion.compare(VERSION, config.version)) {
+          setChecked({ type: "ok", config, hints: [] });
+        } else {
+          setChecked({
+            type: "incompatible",
+            result: config,
+            supported: VERSION,
+          });
+        }
+      } catch (error) {
+        if (error instanceof TalerError) {
+          if (keepRetrying) {
+            setTimeout(() => {
+              testConfig();
+            }, CONFIG_FAIL_TRY_AGAIN_MS);
+          }
+          setChecked({ type: "error", error });
+        } else {
+          setChecked({ type: "error", error: TalerError.fromException(error) });
+        }
+      }
+    }
+    testConfig();
+    return () => {
+      // on unload, stop retry
+      keepRetrying = false;
+    };
+  }, []);
+
+  if (checked === undefined) {
+    return h(frameOnError, {
+      children: h("div", {}, "checking compatibility with server..."),
+    });
+  }
+  if (checked.type === "error") {
+    return h(frameOnError, {
+      children: h(ErrorLoading, { error: checked.error, showDetail: true }),
+    });
+  }
+  if (checked.type === "incompatible") {
+    return h(frameOnError, {
+      children: h(
+        "div",
+        {},
+        i18n.str`The server version is not supported. Supported version "${checked.supported}", server version "${checked.result.version}"`,
+      ),
+    });
+  }
+
+  const value: ChallengerContextType = {
+    url: baseUrl,
+    config: checked.config,
+    onActivity: onActivity,
+    lib,
+    cancelRequest,
+    hints: checked.hints,
+  };
+  return h(ChallengerContext.Provider, {
+    value,
+    children,
+  });
+};
+
+function buildChallengerApiClient(
+  url: URL,
+  evictors: Evictors,
+): APIClient<ChallengerLib, ChallengerApi.ChallengerTermsOfServiceResponse> {
+  const httpFetch = new BrowserFetchHttpLib({
+    enableThrottling: true,
+    requireTls: false,
+  });
+  const tracker = new ActiviyTracker<ObservabilityEvent>();
+  const httpLib = new ObservableHttpClientLibrary(httpFetch, {
+    observe(ev) {
+      tracker.notify(ev);
+    },
+  });
+
+  const bank = new ChallengerHttpClient(url.href, httpLib);
+
+  async function getRemoteConfig(): Promise<ChallengerApi.ChallengerTermsOfServiceResponse> {
+    const resp = await bank.getConfig();
+    if (resp.type === "fail") {
+      throw TalerError.fromUncheckedDetail(resp.detail);
+    }
+    return resp.body;
+  }
+
+  return {
+    getRemoteConfig,
+    VERSION: bank.PROTOCOL_VERSION,
+    lib: {
+      bank,
+    },
+    onActivity: tracker.subscribe,
+    cancelRequest: httpLib.cancelRequest,
+  };
+}
+
+export const ChallengerApiProviderTesting = ({
+  children,
+  value,
+}: {
+  value: ChallengerContextType;
+  children: ComponentChildren;
+}): VNode => {
+  return h(ChallengerContext.Provider, {
+    value,
+    children,
+  });
+};
diff --git a/packages/web-util/src/context/index.ts b/packages/web-util/src/context/index.ts
index 0e28b844a..8e7f096da 100644
--- a/packages/web-util/src/context/index.ts
+++ b/packages/web-util/src/context/index.ts
@@ -5,6 +5,7 @@ export {
   useTranslationContext
 } from "./translation.js";
 export * from "./bank-api.js";
+export * from "./challenger-api.js";
 export * from "./merchant-api.js";
 export * from "./navigation.js";
 export * from "./wallet-integration.js";
diff --git a/packages/web-util/src/context/navigation.ts b/packages/web-util/src/context/navigation.ts
index a2fe3ff12..c2f2bbbc1 100644
--- a/packages/web-util/src/context/navigation.ts
+++ b/packages/web-util/src/context/navigation.ts
@@ -16,17 +16,13 @@
 
 import { ComponentChildren, createContext, h, VNode } from "preact";
 import { useContext, useEffect, useState } from "preact/hooks";
-import { AppLocation, ObjectOf, Location, findMatch, RouteDefinition } from "../utils/route.js";
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function useCurrentLocation<T extends ObjectOf<RouteDefinition<any>>>(
-  pagesMap: T,
-): Location<T> | undefined {
-  const pageList = Object.keys(pagesMap as object) as Array<keyof T>;
-  const { path, params } = useNavigationContext();
-
-  return findMatch(pagesMap, pageList, path, params);
-}
+import {
+  AppLocation,
+  ObjectOf,
+  Location,
+  findMatch,
+  RouteDefinition,
+} from "../utils/route.js";
 
 /**
  *
@@ -35,7 +31,7 @@ export function useCurrentLocation<T extends ObjectOf<RouteDefinition<any>>>(
 
 export type Type = {
   path: string;
-  params: Record<string, string>;
+  params: Record<string, string[]>;
   navigateTo: (path: AppLocation) => void;
   // addNavigationListener: (listener: (path: string, params: Record<string, string>) => void) => (() => void);
 };
@@ -45,13 +41,29 @@ const Context = createContext<Type>(undefined);
 
 export const useNavigationContext = (): Type => useContext(Context);
 
-function getPathAndParamsFromWindow() {
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function useCurrentLocation<T extends ObjectOf<RouteDefinition<any>>>(
+  pagesMap: T,
+): Location<T> | undefined {
+  const pageList = Object.keys(pagesMap as object) as Array<keyof T>;
+  const { path, params } = useNavigationContext();
+
+  return findMatch(pagesMap, pageList, path, params);
+}
+
+function getPathAndParamsFromWindow(): {
+  path: string;
+  params: Record<string, string[]>;
+} {
   const path =
     typeof window !== "undefined" ? window.location.hash.substring(1) : "/";
-  const params: Record<string, string> = {};
+  const params: Record<string, string[]> = {};
   if (typeof window !== "undefined") {
     for (const [key, value] of new URLSearchParams(window.location.search)) {
-      params[key] = value;
+      if (!params[key]) {
+        params[key] = [];
+      }
+      params[key].push(value);
     }
   }
   return { path, params };
@@ -80,14 +92,14 @@ export const BrowserHashNavigationProvider = ({
       "Can't use BrowserHashNavigationProvider if there is no window object",
     );
   }
-  function navigateTo(path: string) {
+  function navigateTo(path: string): void {
     const { params } = getPathAndParamsFromWindow();
     setState({ path, params });
     window.location.href = path;
   }
 
   useEffect(() => {
-    function eventListener() {
+    function eventListener(): void {
       setState(getPathAndParamsFromWindow());
     }
     window.addEventListener(PopStateEventType, eventListener);