@c-rex/services 0.1.2 → 0.1.3

package/dist/index.js

@@ -54,15 +54,16 @@ var FLAGS_BY_LANG = {
   "de": "DE"
 };
 var EN_LANG = "en";
+var TOPIC = "TOPIC";
+var DOCUMENT = "DOCUMENT";
+var PACKAGE = "PACKAGE";
 var RESULT_TYPES = {
-  TOPIC: "TOPIC",
-  DOCUMENT: "DOCUMENT",
-  PACKAGE: "PACKAGE"
+  TOPIC,
+  DOCUMENT,
+  PACKAGE
 };
 var DEFAULT_COOKIE_LIMIT = 7 * 24 * 60 * 60 * 1e3;
-
-// ../core/src/requests.ts
-var import_openid_client = require("openid-client");
+var CREX_TOKEN_HEADER_KEY = "crex-token";
 
 // ../utils/src/utils.ts
 var call = async (method, params) => {
@@ -70,7 +71,8 @@ var call = async (method, params) => {
     const res = await fetch(`${process.env.NEXT_PUBLIC_API_URL}/api/rpc`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ method, params })
+      body: JSON.stringify({ method, params }),
+      credentials: "include"
     });
     const json = await res.json();
     if (!res.ok) throw new Error(json.error || "Unknown error");
@@ -90,23 +92,35 @@ var getCountryCodeByLang = (lang) => {
 };
 
 // ../utils/src/memory.ts
-function isBrowser() {
-  return typeof window !== "undefined" && typeof document !== "undefined";
-}
-function saveInMemory(value, key) {
-  if (isBrowser()) throw new Error("saveInMemory is not supported in browser");
-  if (typeof global !== "undefined" && !(key in global)) {
-    global[key] = null;
+var getCookie = async (key) => {
+  const res = await fetch(`${process.env.NEXT_PUBLIC_API_URL}/api/cookies?key=${key}`);
+  if (!res.ok) {
+    return { key, value: null };
   }
-  const globalConfig = global[key];
-  if (globalConfig === null) {
-    global[key] = value;
+  const json = await res.json();
+  return json;
+};
+var setCookie = async (key, value, maxAge) => {
+  try {
+    if (maxAge === void 0) {
+      maxAge = DEFAULT_COOKIE_LIMIT;
+    }
+    await fetch(`${process.env.NEXT_PUBLIC_API_URL}/api/cookies`, {
+      method: "POST",
+      credentials: "include",
+      body: JSON.stringify({
+        key,
+        value,
+        maxAge
+      })
+    });
+  } catch (error) {
+    call("CrexLogger.log", {
+      level: "error",
+      message: `utils.setCookie error: ${error}`
+    });
   }
-}
-function getFromMemory(key) {
-  if (isBrowser()) throw new Error("getFromMemory is not supported in browser");
-  return global[key];
-}
+};
 
 // ../utils/src/classMerge.ts
 var import_clsx = require("clsx");
@@ -124,55 +138,128 @@ var generateQueryParams = (params) => {
   return queryParams;
 };
 
+// ../utils/src/token.ts
+var updateToken = async () => {
+  try {
+    const response = await fetch(`${process.env.NEXT_PUBLIC_API_URL}/api/token`, {
+      method: "POST",
+      credentials: "include"
+    });
+    const cookies = response.headers.get("set-cookie");
+    if (cookies === null) return null;
+    const aux = cookies.split(`${CREX_TOKEN_HEADER_KEY}=`);
+    if (aux.length == 0) return null;
+    const token = aux[1].split(";")[0];
+    if (token === void 0) throw new Error("Token is undefined");
+    return token;
+  } catch (error) {
+    call("CrexLogger.log", {
+      level: "error",
+      message: `utils.updateToken error: ${error}`
+    });
+    return null;
+  }
+};
+var manageToken = async () => {
+  try {
+    const hasToken = await getCookie(CREX_TOKEN_HEADER_KEY);
+    let token = hasToken.value;
+    if (hasToken.value === null) {
+      const tokenResult = await updateToken();
+      if (tokenResult === null) throw new Error("Token is undefined");
+      token = tokenResult;
+    }
+    return token;
+  } catch (error) {
+    call("CrexLogger.log", {
+      level: "error",
+      message: `utils.manageToken error: ${error}`
+    });
+    return null;
+  }
+};
+
 // ../core/src/requests.ts
 var import_next_cookies = require("@c-rex/utils/next-cookies");
-var CREX_TOKEN_HEADER_KEY = "crex-token";
-var CREX_TOKEN_EXPIRY_HEADER_KEY = "crex-token-expiry";
-var CrexApi = class {
-  customerConfig;
-  apiClient;
-  async manageToken() {
-    const headersAux = {};
-    if (this.customerConfig.OIDC.client.enabled) {
-      let token = getFromMemory(CREX_TOKEN_HEADER_KEY);
-      const tokenExpiry = Number(
-        getFromMemory(CREX_TOKEN_EXPIRY_HEADER_KEY)
-      );
-      const now = Math.floor(Date.now() / 1e3);
-      if (!(token && tokenExpiry > now + 60)) {
-        const { token: tokenAux, tokenExpiry: tokenExpiryAux } = await this.getToken();
-        token = tokenAux;
-        saveInMemory(token, CREX_TOKEN_HEADER_KEY);
-        saveInMemory(tokenExpiryAux.toString(), CREX_TOKEN_EXPIRY_HEADER_KEY);
-      }
-      headersAux["Authorization"] = `Bearer ${token}`;
-    }
-    return headersAux;
+
+// ../core/src/cache.ts
+var CrexCache = class {
+  /**
+   * Retrieves a value from the cache by key.
+   * 
+   * @param key - The cache key to retrieve
+   * @returns The cached value as a string, or null if not found
+   */
+  async get(key) {
+    const cookie = await getCookie(key);
+    return cookie.value;
   }
-  async getToken() {
-    let token = "";
-    let tokenExpiry = 0;
+  /**
+   * Stores a value in the cache with the specified key.
+   * Checks if the value size is within cookie size limits (4KB).
+   * 
+   * @param key - The cache key
+   * @param value - The value to store
+   */
+  async set(key, value) {
     try {
-      const now = Math.floor(Date.now() / 1e3);
-      const issuer = await import_openid_client.Issuer.discover(this.customerConfig.OIDC.client.issuer);
-      const client = new issuer.Client({
-        client_id: this.customerConfig.OIDC.client.id,
-        client_secret: this.customerConfig.OIDC.client.secret
-      });
-      const tokenSet = await client.grant({ grant_type: "client_credentials" });
-      token = tokenSet.access_token;
-      tokenExpiry = now + tokenSet.expires_at;
+      const byteLength = new TextEncoder().encode(value).length;
+      if (byteLength <= 4096) {
+        await setCookie(key, value);
+      } else {
+        console.warn(`Cookie ${key} value is too large to be stored in a single cookie`);
+      }
     } catch (error) {
       call("CrexLogger.log", {
         level: "error",
-        message: `API.getToken error when request ${this.customerConfig.OIDC.client.issuer}. Error: ${error}`
+        message: `CrexCache.set error: ${error}`
       });
     }
-    return {
-      token,
-      tokenExpiry
-    };
   }
+  /**
+   * Generates a cache key based on request parameters.
+   * Combines URL, method, and optionally params, body, and headers into a single string key.
+   * 
+   * @param options - Request options to generate key from
+   * @param options.url - The request URL
+   * @param options.method - The HTTP method
+   * @param options.body - Optional request body
+   * @param options.params - Optional query parameters
+   * @param options.headers - Optional request headers
+   * @returns A string cache key
+   */
+  generateCacheKey({
+    url,
+    method,
+    body,
+    params,
+    headers
+  }) {
+    let cacheKey = `${url}-${method}`;
+    if (params !== void 0 && Object.keys(params).length > 0) {
+      cacheKey += `-${JSON.stringify(params)}`;
+    }
+    if (body !== void 0 && Object.keys(body).length > 0) {
+      cacheKey += `-${JSON.stringify(body)}`;
+    }
+    if (headers !== void 0 && Object.keys(headers).length > 0) {
+      cacheKey += `-${JSON.stringify(headers)}`;
+    }
+    return cacheKey;
+  }
+};
+
+// ../core/src/requests.ts
+var CrexApi = class {
+  customerConfig;
+  apiClient;
+  cache;
+  /**
+   * Initializes the API client if it hasn't been initialized yet.
+   * Loads customer configuration, creates the axios instance, and initializes the cache.
+   * 
+   * @private
+   */
   async initAPI() {
     if (!this.customerConfig) {
       this.customerConfig = await (0, import_next_cookies.getConfigs)();
@@ -182,7 +269,22 @@ var CrexApi = class {
         baseURL: this.customerConfig.baseUrl
       });
     }
+    if (!this.cache) {
+      this.cache = new CrexCache();
+    }
   }
+  /**
+   * Executes an API request with caching, authentication, and retry logic.
+   * 
+   * @param options - Request options
+   * @param options.url - The URL to request
+   * @param options.method - The HTTP method to use
+   * @param options.params - Optional query parameters
+   * @param options.body - Optional request body
+   * @param options.headers - Optional request headers
+   * @returns The response data
+   * @throws Error if the request fails after maximum retries
+   */
   async execute({
     url,
     method,
@@ -192,10 +294,14 @@ var CrexApi = class {
   }) {
     await this.initAPI();
     let response = void 0;
-    headers = {
-      ...headers,
-      ...await this.manageToken()
-    };
+    if (this.customerConfig.OIDC.client.enabled) {
+      const token = await manageToken();
+      headers = {
+        ...headers,
+        Authorization: `Bearer ${token}`
+      };
+      this.apiClient.defaults.headers.common["Authorization"] = `Bearer ${token}`;
+    }
     for (let retry = 0; retry < API.MAX_RETRY; retry++) {
       try {
         response = await this.apiClient.request({
@@ -281,7 +387,15 @@ var RenditionsService = class extends BaseService {
   constructor() {
     super("Renditions/");
   }
-  async getHTMLRendition(renditions) {
+  /**
+   * Retrieves the HTML rendition from a list of renditions.
+   * Filters for renditions with format 'application/xhtml+xml' and rel 'view'.
+   * 
+   * @param renditions - Array of rendition objects to process
+   * @returns A promise that resolves to the HTML content as a string, or empty string if no suitable rendition is found
+   * @throws Error if the API request fails
+   */
+  async getHTMLRendition({ renditions }) {
     const filteredRenditions = renditions.filter(
       (item2) => item2.format == "application/xhtml+xml"
     );
@@ -299,7 +413,14 @@ var RenditionsService = class extends BaseService {
     });
     return response;
   }
-  getFileRenditions = (renditions) => {
+  /**
+   * Processes a list of renditions and categorizes them into files to download and files to open.
+   * Excludes renditions with formats 'application/xhtml+xml', 'application/json', and 'application/llm+xml'.
+   * 
+   * @param renditions - Array of rendition objects to process
+   * @returns An object containing arrays of file renditions categorized as 'filesToDownload' and 'filesToOpen'
+   */
+  getFileRenditions = ({ renditions }) => {
     if (renditions == void 0 || renditions.length == 0) {
       return {
         filesToDownload: [],
@@ -341,11 +462,26 @@ var DirectoryNodesService = class extends BaseService {
   constructor() {
     super("DirectoryNodes/");
   }
+  /**
+   * Retrieves a specific directory node by its ID.
+   * 
+   * @param id - The unique identifier of the directory node
+   * @returns A promise that resolves to the directory node data
+   * @throws Error if the API request fails
+   */
   async getItem(id) {
     return await this.request({
       path: id
     });
   }
+  /**
+   * Retrieves a list of directory nodes based on specified filters.
+   * 
+   * @param options - Options for filtering the directory nodes list
+   * @param options.filters - Optional array of filter strings to apply
+   * @returns A promise that resolves to the directory nodes response
+   * @throws Error if the API request fails
+   */
   async getList({
     filters = []
   }) {
@@ -375,6 +511,14 @@ var DocumentTypesService = class extends BaseService {
   constructor() {
     super("DocumentTypes/");
   }
+  /**
+   * Retrieves document type labels for the specified fields.
+   * The labels are restricted to English language (EN-us).
+   * 
+   * @param fields - Array of field names to retrieve labels for
+   * @returns A promise that resolves to an array of label strings
+   * @throws Error if the API request fails
+   */
   async getLabels(fields) {
     const params = [
       {
@@ -393,13 +537,15 @@ var DocumentTypesService = class extends BaseService {
 // src/transforms/information.ts
 var import_next_cookies2 = require("@c-rex/utils/next-cookies");
 var transformInformationUnits = async (data) => {
-  const config = await (0, import_next_cookies2.getConfigs)();
+  const config = (0, import_next_cookies2.getConfigs)();
   const items = await Promise.all(data.items.map(async (item) => {
-    let link = `/topics/${item.shortId}`;
     const type = item.class.labels.filter((item2) => item2.language === EN_LANG)[0].value.toUpperCase();
     const service = new RenditionsService();
-    const { filesToOpen, filesToDownload } = service.getFileRenditions(item?.renditions);
-    if (type == RESULT_TYPES.DOCUMENT) {
+    const { filesToOpen, filesToDownload } = service.getFileRenditions({ renditions: item?.renditions });
+    let link = `/topics/${item.shortId}`;
+    if (config.results.articlePageLayout == "BLOG") {
+      link = `/blog/${item.shortId}`;
+    } else if (type == RESULT_TYPES.DOCUMENT) {
       link = `/documents/${item.shortId}`;
     }
     return {
@@ -425,6 +571,18 @@ var InformationUnitsService = class extends BaseService {
   constructor() {
     super("InformationUnits/");
   }
+  /**
+   * Retrieves a list of information units based on specified criteria.
+   * 
+   * @param options - Options for filtering and paginating the information units list
+   * @param options.queries - Optional search query string
+   * @param options.page - Optional page number for pagination (defaults to 1)
+   * @param options.fields - Optional array of fields to include in the response
+   * @param options.filters - Optional array of filter strings to apply
+   * @param options.languages - Optional array of language codes to filter by
+   * @returns A promise that resolves to the information units response
+   * @throws Error if the API request fails
+   */
   async getList({
     queries = "",
     page = 1,
@@ -455,6 +613,15 @@ var InformationUnitsService = class extends BaseService {
       transformer: transformInformationUnits
     });
   }
+  /**
+   * Retrieves a specific information unit by its ID.
+   * Includes renditions, directory nodes, version information, titles, languages, and labels.
+   * 
+   * @param options - Options for retrieving the information unit
+   * @param options.id - The unique identifier of the information unit
+   * @returns A promise that resolves to the information unit data
+   * @throws Error if the API request fails
+   */
   async getItem({ id }) {
     const params = [
       { key: "Fields", value: "renditions" },
@@ -469,21 +636,44 @@ var InformationUnitsService = class extends BaseService {
       params
     });
   }
-  async getSuggestions({ query }) {
+  /**
+   * Retrieves autocomplete suggestions based on a query prefix.
+   * 
+   * @param options - Options for retrieving suggestions
+   * @param options.query - The query prefix to get suggestions for
+   * @param options.language - The language of the suggestions
+   * @returns A promise that resolves to an array of suggestion strings
+   * @throws Error if the API request fails
+   */
+  async getSuggestions({ query, language }) {
     return await this.request({
       path: `Suggestions`,
-      params: [{ key: "prefix", value: query }],
+      params: [
+        { key: "prefix", value: query },
+        { key: "lang", value: language }
+      ],
       transformer: (data) => {
-        return data.suggestions.map((item) => item.value);
+        const suggestions = [];
+        const comparableList = [];
+        data.suggestions.forEach((item) => {
+          suggestions.push(item.value);
+          comparableList.push(item.value.toLowerCase());
+        });
+        if (!comparableList.includes(query.toLowerCase())) {
+          return [query, ...suggestions];
+        }
+        return suggestions;
       }
     });
   }
 };
 
 // src/language.ts
+var import_next_cookies3 = require("@c-rex/utils/next-cookies");
 var LanguageService = class extends BaseService {
-  constructor(endpoint) {
-    super(endpoint);
+  constructor() {
+    const configs = (0, import_next_cookies3.getConfigs)();
+    super(configs.languageSwitcher.endpoint);
   }
   /*
       public static async getInstance(): Promise<LanguageService> {
@@ -495,6 +685,13 @@ var LanguageService = class extends BaseService {
           return LanguageService.instance;
       }
       */
+  /**
+   * Retrieves a list of available languages and their associated countries.
+   * Transforms the API response to include language code, country code, and original value.
+   * 
+   * @returns A promise that resolves to an array of language and country objects
+   * @throws Error if the API request fails
+   */
   async getLanguagesAndCountries() {
     return await this.request({
       transformer: (data) => {