@c-rex/contexts 0.1.11 → 0.1.13

package/package.json

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

package/src/config-provider.tsx

@@ -1,15 +1,14 @@
 "use client"
 
-import { CREX_TOKEN_HEADER_KEY, UI_LANG_OPTIONS } from '@c-rex/constants'
-import { ConfigInterface, LanguageAndCountries, AvailableVersionsInterface } from '@c-rex/interfaces'
+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 { getConfigs } from '@c-rex/utils/next-cookies'
 import React, { createContext, useContext, useEffect, useState } from 'react'
 import { useLanguageStore } from '@c-rex/components/language-store'
 
 type AppConfigContextType = {
     error: Error | null
-    configs: ConfigInterface
+    configs: CookiesConfigs
     loading: boolean
     packageID: string | null
     articleLang: string | null
@@ -23,60 +22,58 @@ const AppConfigContext = createContext<AppConfigContextType | undefined>(undefin
 
 export const AppConfigProvider = ({ children }: { children: React.ReactNode }) => {
     const [error, setError] = useState<Error | null>(null)
-    const [configs, setConfigs] = useState<ConfigInterface | null>(null)
+    const [configs, setConfigs] = useState<CookiesConfigs | null>(null)
     const [loading, setLoading] = useState(true)
     const [packageID, setPackageID] = useState<string | null>(null)
     const [articleLang, setArticleLang] = useState<string | null>(null)
     const [availableVersions, setAvailableVersions] = useState<AvailableVersionsInterface[] | null>(null)
 
-
-    const manageUILanguage = async (configs: ConfigInterface): 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: ConfigInterface): 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: ConfigInterface): 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,32 +83,60 @@ export const AppConfigProvider = ({ children }: { children: React.ReactNode }) =
         }
     }
 
-    const requestToken = async (configs: ConfigInterface): Promise<void> => {
+    const requestToken = async (): Promise<void> => {
         try {
-            await fetch(`${configs.publicNextApiUrl}/api/token`, {
+            const response = await fetch(`/api/token`, {
                 method: 'POST',
                 credentials: 'include',
             });
+
+            const { token } = await response.json();
+
+            return token;
         } catch (error) {
             call("CrexLogger.log", {
                 level: "error",
                 message: `config-provider.requestToken error: ${error}`
             });
+
+            await new Promise(resolve => setTimeout(resolve, API.RETRY_DELAY));
         }
     }
 
-    const interval = async (delayMs: number, configs: ConfigInterface) => {
+    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 +146,16 @@ export const AppConfigProvider = ({ children }: { children: React.ReactNode }) =
             try {
                 setLoading(true)
 
-                const configsResult = await getConfigs()
-                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()
                 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 = {