@c-rex/contexts 0.1.12 → 0.1.14

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@c-rex/contexts",
-    "version": "0.1.12",
+    "version": "0.1.14",
     "type": "module",
     "files": [
         "src"

package/src/config-provider.tsx

@@ -1,9 +1,8 @@
 "use client"
 
-import { CREX_TOKEN_HEADER_KEY, UI_LANG_OPTIONS } from '@c-rex/constants'
+import { API, CREX_TOKEN_HEADER_KEY, SDK_CONFIG_KEY, UI_LANG_OPTIONS } from '@c-rex/constants'
 import { CookiesConfigs, LanguageAndCountries, AvailableVersionsInterface } from '@c-rex/interfaces'
 import { call } from '@c-rex/utils'
-import { getClientConfigs } from '@c-rex/utils/next-cookies'
 import React, { createContext, useContext, useEffect, useState } from 'react'
 import { useLanguageStore } from '@c-rex/components/language-store'
 
@@ -29,54 +28,52 @@ export const AppConfigProvider = ({ children }: { children: React.ReactNode }) =
     const [articleLang, setArticleLang] = useState<string | null>(null)
     const [availableVersions, setAvailableVersions] = useState<AvailableVersionsInterface[] | null>(null)
 
-
-    const manageUILanguage = async (configs: CookiesConfigs): Promise<void> => {
+    const manageUILanguage = (configs: CookiesConfigs): void => {
         const uiLang = useLanguageStore.getState().uiLang;
-        const setUiLang = useLanguageStore.getState().setUiLang;
-        let locale = uiLang
 
-        if (locale.length === 0) {
+        if (uiLang.length === 0) {
+            const setUiLang = useLanguageStore.getState().setUiLang;
             const browserLang = navigator.language;
 
-            locale = UI_LANG_OPTIONS.includes(browserLang.toLowerCase())
+            const locale = UI_LANG_OPTIONS.includes(browserLang.toLowerCase())
                 ? browserLang
                 : configs.languageSwitcher.default;
+
+            setUiLang(locale)
         }
-        setUiLang(locale)
     }
 
-    const manageContentLanguage = async (configs: CookiesConfigs): Promise<void> => {
+    const manageContentLanguage = (configs: CookiesConfigs): void => {
         const contentLang = useLanguageStore.getState().contentLang;
-        const setContentLang = useLanguageStore.getState().setContentLang;
-        const availableLanguages = useLanguageStore.getState().availableLanguages;
 
-        let locale = contentLang
-        if (locale.length === 0) {
+        if (contentLang.length === 0) {
+            const setContentLang = useLanguageStore.getState().setContentLang;
+            const availableLanguages = useLanguageStore.getState().availableLanguages;
+
             const browserLang = navigator.language;
             const hasLang = availableLanguages.some((item) => item.value === browserLang);
 
-            locale = hasLang
+            const locale = hasLang
                 ? browserLang
                 : configs.languageSwitcher.default;
-        }
 
-        setContentLang(locale)
+            setContentLang(locale)
+        }
     }
 
-    const manageToken = async (configs: CookiesConfigs): Promise<void> => {
+    const manageToken = async (): Promise<void> => {
         try {
-            const url = configs.publicNextApiUrl
-            const res = await fetch(`${url}/api/cookies?key=${CREX_TOKEN_HEADER_KEY}`);
+            const res = await fetch(`/api/cookies?key=${CREX_TOKEN_HEADER_KEY}`);
 
             if (!res.ok) {
-                await requestToken(configs);
+                await requestToken();
                 return
             }
 
             const hasToken = await res.json();
 
             if (hasToken.value === null) {
-                await requestToken(configs);
+                await requestToken();
             }
         } catch (error) {
             call("CrexLogger.log", {
@@ -86,12 +83,16 @@ export const AppConfigProvider = ({ children }: { children: React.ReactNode }) =
         }
     }
 
-    const requestToken = async (configs: CookiesConfigs): Promise<void> => {
+    const requestToken = async (): Promise<void> => {
         try {
-            await fetch(`${configs.publicNextApiUrl}/api/token`, {
+            const response = await fetch('/api/oidc/token', {
                 method: 'POST',
                 credentials: 'include',
             });
+
+            const { token } = await response.json();
+
+            return token;
         } catch (error) {
             call("CrexLogger.log", {
                 level: "error",
@@ -100,18 +101,54 @@ export const AppConfigProvider = ({ children }: { children: React.ReactNode }) =
         }
     }
 
-    const interval = async (delayMs: number, configs: CookiesConfigs) => {
+    const updateIssuerMetadata = async (): Promise<void> => {
+        try {
+            await fetch('/api/oidc/issuer', {
+                method: 'POST',
+                credentials: 'include',
+            });
+        } catch (error) {
+            call("CrexLogger.log", {
+                level: "error",
+                message: `config-provider.updateIssuerMetadata error: ${error}`
+            });
+        }
+    }
+
+    const interval = async (delayMs: number) => {
         while (true) {
             await new Promise(resolve => setTimeout(resolve, delayMs));
-            await manageToken(configs);
+            await manageToken();
         }
     }
 
     const updateLanguages = async () => {
-        const setAvailableLanguages = useLanguageStore.getState().setAvailableLanguages;
+        const availableLanguages = useLanguageStore.getState().availableLanguages;
+
+        if (availableLanguages.length === 0) {
+            const setAvailableLanguages = useLanguageStore.getState().setAvailableLanguages;
+
+            const langs = await call<LanguageAndCountries[]>("LanguageService.getLanguagesAndCountries")
+            setAvailableLanguages(langs)
+        }
+    }
 
-        const langs = await call<LanguageAndCountries[]>("LanguageService.getLanguagesAndCountries")
-        setAvailableLanguages(langs)
+    const getClientConfig = async (): Promise<CookiesConfigs> => {
+        const res = await fetch(`/api/cookies?key=${SDK_CONFIG_KEY}`);
+
+        if (!res.ok) {
+            throw new Error('Failed to fetch token from cookies API');
+        }
+
+        const jsonConfig = await res.json();
+
+        if (jsonConfig.value === null) {
+            throw new Error('Client config not found in cookies');
+        }
+
+        const configs: CookiesConfigs = JSON.parse(jsonConfig.value);
+
+        return configs;
     }
 
     useEffect(() => {
@@ -121,22 +158,17 @@ export const AppConfigProvider = ({ children }: { children: React.ReactNode }) =
             try {
                 setLoading(true)
 
-                const configsResult = await getClientConfigs()
-                if (!configsResult) {
-                    throw new Error("Config cookie not available");
-                }
-
-                await manageToken(configsResult)
+                const configsResult = await getClientConfig()
 
-                await Promise.all([
-                    manageUILanguage(configsResult),
-                    manageContentLanguage(configsResult),
-                    updateLanguages()
-                ])
+                await manageToken()
 
+                manageUILanguage(configsResult)
+                manageContentLanguage(configsResult)
+                updateLanguages()
+                updateIssuerMetadata()
                 setError(null)
                 setConfigs(configsResult)
-                interval(1000 * 60 * 9, configsResult);
+                interval(1000 * 60 * 9);
             } catch (err) {
                 call("CrexLogger.log", {
                     level: "error",

package/src/search.tsx

@@ -1,6 +1,6 @@
 "use client"
 
-import { createContext, useContext, ReactNode, useState, useEffect, use } from "react";
+import { createContext, useContext, ReactNode, useState } from "react";
 import { Loading } from "@c-rex/components/loading";
 
 type SearchContextProps = {