@c-rex/services 0.1.1 → 0.1.3

package/dist/index.js

@@ -49,14 +49,21 @@ var API = {
     "content-Type": "application/json"
   }
 };
-var SDK_CONFIG_KEY = "crex-sdk-config";
 var FLAGS_BY_LANG = {
   "en": "US",
   "de": "DE"
 };
-
-// ../core/src/requests.ts
-var import_openid_client = require("openid-client");
+var EN_LANG = "en";
+var TOPIC = "TOPIC";
+var DOCUMENT = "DOCUMENT";
+var PACKAGE = "PACKAGE";
+var RESULT_TYPES = {
+  TOPIC,
+  DOCUMENT,
+  PACKAGE
+};
+var DEFAULT_COOKIE_LIMIT = 7 * 24 * 60 * 60 * 1e3;
+var CREX_TOKEN_HEADER_KEY = "crex-token";
 
 // ../utils/src/utils.ts
 var call = async (method, params) => {
@@ -64,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");
@@ -84,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");
@@ -118,68 +138,153 @@ 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);
-      let tokenExpiry = 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, 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;
-      console.log("token", token);
+      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) {
-      const jsonConfigs = await (0, import_next_cookies.getCookie)(SDK_CONFIG_KEY);
-      if (!jsonConfigs) {
-        throw new Error("SDK not initialized");
-      }
-      this.customerConfig = JSON.parse(jsonConfigs);
+      this.customerConfig = await (0, import_next_cookies.getConfigs)();
     }
     if (!this.apiClient) {
       this.apiClient = import_axios.default.create({
         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,
@@ -189,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({
@@ -204,10 +313,10 @@ var CrexApi = class {
         });
         break;
       } catch (error) {
-        console.log(
-          "error",
-          `API.execute ${retry + 1}\xBA error when request ${url}. Error: ${error}`
-        );
+        call("CrexLogger.log", {
+          level: "error",
+          message: `API.execute ${retry + 1}\xBA error when request ${url}. Error: ${error}`
+        });
         if (retry === API.MAX_RETRY - 1) {
           throw error;
         }
@@ -224,10 +333,26 @@ var CrexApi = class {
 var BaseService = class {
   api;
   endpoint;
+  /**
+   * Creates a new instance of BaseService.
+   * 
+   * @param endpoint - The API endpoint URL for this service
+   */
   constructor(endpoint) {
     this.api = new CrexApi();
     this.endpoint = endpoint;
   }
+  /**
+   * Makes an API request to the specified endpoint.
+   * 
+   * @param options - Request configuration options
+   * @param options.path - Optional path to append to the endpoint
+   * @param options.params - Optional query parameters to include in the request
+   * @param options.method - HTTP method to use (defaults to 'get')
+   * @param options.transformer - Optional function to transform the response data
+   * @returns The response data, optionally transformed
+   * @throws Error if the API request fails
+   */
   async request({
     path = "",
     method = "get",
@@ -262,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"
     );
@@ -280,17 +413,48 @@ var RenditionsService = class extends BaseService {
     });
     return response;
   }
-  async getDocumentRendition(renditions, type) {
+  /**
+   * 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: [],
+        filesToOpen: []
+      };
+    }
     const filteredRenditions = renditions.filter(
-      (item2) => item2.format == `application/${type}`
+      (item) => item.format != "application/xhtml+xml" && item.format != "application/json" && item.format != "application/llm+xml"
     );
-    if (filteredRenditions.length == 0 || filteredRenditions[0] == void 0) return "";
-    const item = filteredRenditions[0];
-    const filteredLinks = item.links.filter((item2) => item2.rel == "view");
-    if (filteredLinks.length == 0 || filteredLinks[0] == void 0) return "";
-    const url = filteredLinks[0].href;
-    return url;
-  }
+    if (filteredRenditions.length == 0 || filteredRenditions[0] == void 0) {
+      return {
+        filesToDownload: [],
+        filesToOpen: []
+      };
+    }
+    const filesToDownload = filteredRenditions.map((item) => {
+      const filteredLinks = item.links.filter((item2) => item2.rel == "download");
+      return {
+        format: item.format,
+        link: filteredLinks[0].href
+      };
+    });
+    const filesToOpen = filteredRenditions.map((item) => {
+      const filteredLinks = item.links.filter((item2) => item2.rel == "view");
+      return {
+        format: item.format,
+        link: filteredLinks[0].href
+      };
+    });
+    return {
+      filesToDownload,
+      filesToOpen
+    };
+  };
 };
 
 // src/directoryNodes.ts
@@ -298,11 +462,36 @@ 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 = []
+  }) {
+    const remainFilters = createParams(filters, "Filter");
+    return await this.request({
+      params: {
+        ...remainFilters
+      }
+    });
+  }
 };
 
 // src/transforms/documentTypes.ts
@@ -322,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 = [
       {
@@ -338,9 +535,33 @@ var DocumentTypesService = class extends BaseService {
 };
 
 // src/transforms/information.ts
-var transformInformationUnits = (data) => {
+var import_next_cookies2 = require("@c-rex/utils/next-cookies");
+var transformInformationUnits = async (data) => {
+  const config = (0, import_next_cookies2.getConfigs)();
+  const items = await Promise.all(data.items.map(async (item) => {
+    const type = item.class.labels.filter((item2) => item2.language === EN_LANG)[0].value.toUpperCase();
+    const service = new RenditionsService();
+    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 {
+      language: item.labels[0].language,
+      title: item.labels[0].value,
+      type,
+      localeType: "",
+      shortId: item.shortId,
+      disabled: config.results.disabledResults.includes(type),
+      link,
+      filesToOpen,
+      filesToDownload
+    };
+  }));
   return {
-    items: data.items.map((item) => item),
+    items,
     pageInfo: data.pageInfo
   };
 };
@@ -350,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,
@@ -364,8 +597,8 @@ var InformationUnitsService = class extends BaseService {
       "Filter"
     );
     const params = [
-      { key: "pageSize", value: "9" },
-      { key: "PageNumber", value: (page - 1).toString() },
+      { key: "pageSize", value: "12" },
+      { key: "PageNumber", value: page.toString() },
       ...remainFields,
       ...languageParams,
       ...remainFilters
@@ -380,42 +613,71 @@ 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" },
       { key: "Fields", value: "directoryNodes" },
       { key: "Fields", value: "versionOf" },
-      { key: "Fields", value: "titles" }
+      { key: "Fields", value: "titles" },
+      { key: "Fields", value: "languages" },
+      { key: "Fields", value: "labels" }
     ];
     return await this.request({
       path: id,
       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> {
-          const jsonConfigs = await getCookie(SDK_CONFIG_KEY);
-          if (!jsonConfigs) {
-              throw new Error("SDK not initialized");
-          }
-  
-          const customerConfig = JSON.parse(jsonConfigs) as ConfigInterface;
+          const customerConfig = await getConfigs()
   
           if (!LanguageService.instance) {
               LanguageService.instance = new LanguageService(customerConfig.languageSwitcher.endpoint);
@@ -423,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) => {