@c-rex/services 0.1.2 → 0.1.4

package/dist/index.js

@@ -42,6 +42,14 @@ module.exports = __toCommonJS(index_exports);
 var import_axios = __toESM(require("axios"));
 
 // ../constants/src/index.ts
+var ALL = "*";
+var LOG_LEVELS = {
+  critical: 2,
+  error: 3,
+  warning: 4,
+  info: 6,
+  debug: 7
+};
 var API = {
   MAX_RETRY: 3,
   API_TIMEOUT: 1e4,
@@ -49,140 +57,241 @@ var API = {
     "content-Type": "application/json"
   }
 };
+var SDK_CONFIG_KEY = "crex-sdk-config";
 var FLAGS_BY_LANG = {
   "en": "US",
   "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;
+var CREX_TOKEN_HEADER_KEY = "crex-token";
 
 // ../core/src/requests.ts
-var import_openid_client = require("openid-client");
+var import_headers = require("next/headers");
 
-// ../utils/src/utils.ts
-var call = async (method, params) => {
-  try {
-    const res = await fetch(`${process.env.NEXT_PUBLIC_API_URL}/api/rpc`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ method, params })
+// ../core/src/logger.ts
+var import_winston = __toESM(require("winston"));
+
+// ../core/src/transports/matomo.ts
+var import_winston_transport = __toESM(require("winston-transport"));
+var MatomoTransport = class extends import_winston_transport.default {
+  matomoTransport;
+  configs;
+  /**
+   * Creates a new instance of MatomoTransport.
+   * 
+   * @param configs - The application configuration containing logging settings
+   */
+  constructor(configs) {
+    super({
+      level: configs.logs.matomo.minimumLevel,
+      silent: configs.logs.matomo.silent
     });
-    const json = await res.json();
-    if (!res.ok) throw new Error(json.error || "Unknown error");
-    return json.data;
-  } catch (error) {
-    console.error(error);
-    return null;
+    this.matomoTransport = new import_winston_transport.default();
+    this.configs = configs;
   }
-};
-var getCountryCodeByLang = (lang) => {
-  const mappedKeys = Object.keys(FLAGS_BY_LANG);
-  if (!mappedKeys.includes(lang)) {
-    return lang;
+  /**
+   * Logs a message to Matomo if the message category is included in the configured categories.
+   * 
+   * @param info - The log information including level, message, and category
+   * @param callback - Callback function to execute after logging
+   */
+  log(info, callback) {
+    const matomoCategory = this.configs.logs.matomo.categoriesLevel;
+    if (matomoCategory.includes(info.category) || matomoCategory.includes(ALL)) {
+      this.matomoTransport.log(info, callback);
+    }
   }
-  const country = FLAGS_BY_LANG[lang];
-  return country;
 };
 
-// ../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;
-  }
-  const globalConfig = global[key];
-  if (globalConfig === null) {
-    global[key] = value;
-  }
-}
-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");
-var import_tailwind_merge = require("tailwind-merge");
+// ../core/src/transports/graylog.ts
+var import_winston_transport2 = __toESM(require("winston-transport"));
+var import_winston_graylog2 = __toESM(require("winston-graylog2"));
+var GraylogTransport = class extends import_winston_transport2.default {
+  graylogTransport;
+  configs;
+  /**
+   * Creates a new instance of GraylogTransport.
+   * 
+   * @param configs - The application configuration containing logging settings
+   */
+  constructor(configs) {
+    super({
+      level: configs.logs.graylog.minimumLevel,
+      silent: configs.logs.graylog.silent
+    });
+    this.configs = configs;
+    this.graylogTransport = new import_winston_graylog2.default({
+      name: "crex.net.documentation",
+      //name: "crex.net.blog",
+      silent: false,
+      handleExceptions: false,
+      graylog: {
+        servers: [
+          { host: "localhost", port: 12201 },
+          { host: "https://log.c-rex.net", port: 12202 }
+          //TODO: check the URL => https://log.c-rex.net:12202/gelf"  GELF??
+        ]
+      }
+    });
+  }
+  /**
+   * Logs a message to Graylog if the message category is included in the configured categories.
+   * 
+   * @param info - The log information including level, message, and category
+   * @param callback - Callback function to execute after logging
+   */
+  log(info, callback) {
+    const graylogCategory = this.configs.logs.graylog.categoriesLevel;
+    if (graylogCategory.includes(info.category) || graylogCategory.includes(ALL)) {
+      this.graylogTransport.log(info, callback);
+    }
+  }
+};
 
-// ../utils/src/params.ts
-var createParams = (fieldsList, key = "Fields") => fieldsList.map((item) => ({
-  key,
-  value: item
-}));
-var generateQueryParams = (params) => {
-  const queryParams = params.map(
-    (param) => `${encodeURIComponent(param.key)}=${encodeURIComponent(param.value)}`
-  ).join("&");
-  return queryParams;
+// ../core/src/logger.ts
+var import_next_cookies = require("@c-rex/utils/next-cookies");
+var CrexLogger = class {
+  customerConfig;
+  logger;
+  /**
+   * Initializes the logger instance if it hasn't been initialized yet.
+   * Loads customer configuration and creates the logger with appropriate transports.
+   * 
+   * @private
+   */
+  async initLogger() {
+    try {
+      if (!this.customerConfig) {
+        this.customerConfig = await (0, import_next_cookies.getConfigs)();
+      }
+      if (!this.logger) {
+        this.logger = this.createLogger();
+      }
+    } catch (error) {
+      console.error("Error initializing logger:", error);
+    }
+  }
+  /**
+   * Logs a message with the specified level and optional category.
+   * 
+   * @param options - Logging options
+   * @param options.level - The log level (error, warn, info, etc.)
+   * @param options.message - The message to log
+   * @param options.category - Optional category for the log message
+   */
+  async log({ level, message, category }) {
+    await this.initLogger();
+    this.logger.log(level, message, category);
+  }
+  /**
+   * Creates a new Winston logger instance with configured transports.
+   * 
+   * @private
+   * @returns A configured Winston logger instance
+   */
+  createLogger() {
+    return import_winston.default.createLogger({
+      levels: LOG_LEVELS,
+      transports: [
+        new import_winston.default.transports.Console({
+          level: this.customerConfig.logs.console.minimumLevel,
+          silent: this.customerConfig.logs.console.silent
+        }),
+        new MatomoTransport(this.customerConfig),
+        new GraylogTransport(this.customerConfig)
+      ]
+    });
+  }
 };
 
 // ../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);
+  logger;
+  /**
+   * Initializes the API client if it hasn't been initialized yet.
+   * Loads customer configuration, creates the axios instance, and initializes the logger.
+   * 
+   * @private
+   */
+  async initAPI() {
+    this.logger = new CrexLogger();
+    if (!this.customerConfig) {
+      const aux = (0, import_headers.cookies)().get(SDK_CONFIG_KEY);
+      if (aux != void 0) {
+        this.customerConfig = JSON.parse(aux.value);
+      } else {
+        this.logger.log({
+          level: "error",
+          message: `utils.initAPI error: Config cookie not available`
+        });
+        throw new Error("Config cookie not available");
       }
-      headersAux["Authorization"] = `Bearer ${token}`;
     }
-    return headersAux;
+    if (!this.apiClient) {
+      this.apiClient = import_axios.default.create({
+        baseURL: this.customerConfig.baseUrl
+      });
+    }
   }
   async getToken() {
-    let token = "";
-    let tokenExpiry = 0;
     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 response = await fetch(`${process.env.NEXT_PUBLIC_API_URL}/api/token`, {
+        method: "POST",
+        credentials: "include"
       });
-      const tokenSet = await client.grant({ grant_type: "client_credentials" });
-      token = tokenSet.access_token;
-      tokenExpiry = now + tokenSet.expires_at;
+      const { token } = await response.json();
+      return token;
     } catch (error) {
-      call("CrexLogger.log", {
+      this.logger.log({
         level: "error",
-        message: `API.getToken error when request ${this.customerConfig.OIDC.client.issuer}. Error: ${error}`
+        message: `utils.getToken error: ${error}`
       });
+      throw error;
     }
-    return {
-      token,
-      tokenExpiry
-    };
   }
-  async initAPI() {
-    if (!this.customerConfig) {
-      this.customerConfig = await (0, import_next_cookies.getConfigs)();
-    }
-    if (!this.apiClient) {
-      this.apiClient = import_axios.default.create({
-        baseURL: this.customerConfig.baseUrl
+  async manageToken() {
+    try {
+      let token = "";
+      const hasToken = (0, import_headers.cookies)().get(CREX_TOKEN_HEADER_KEY);
+      if (hasToken == void 0 || hasToken.value === null) {
+        const tokenResult = await this.getToken();
+        if (tokenResult === null) throw new Error("Token is undefined");
+        token = tokenResult;
+      } else {
+        token = hasToken.value;
+      }
+      return token;
+    } catch (error) {
+      this.logger.log({
+        level: "error",
+        message: `utils.manageToken error: ${error}`
       });
+      throw error;
     }
   }
+  /**
+   * 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 +301,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 this.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({
@@ -207,7 +320,7 @@ var CrexApi = class {
         });
         break;
       } catch (error) {
-        call("CrexLogger.log", {
+        this.logger.log({
           level: "error",
           message: `API.execute ${retry + 1}\xBA error when request ${url}. Error: ${error}`
         });
@@ -223,6 +336,106 @@ var CrexApi = class {
   }
 };
 
+// ../utils/src/utils.ts
+var _generateShaKey = async (input) => {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(input);
+  const hashBuffer = await crypto.subtle.digest("SHA-1", data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const base64url = btoa(String.fromCharCode(...hashArray)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  return base64url.slice(0, 12);
+};
+var getCountryCodeByLang = (lang) => {
+  const mappedKeys = Object.keys(FLAGS_BY_LANG);
+  if (!mappedKeys.includes(lang)) {
+    return lang;
+  }
+  const country = FLAGS_BY_LANG[lang];
+  return country;
+};
+
+// ../utils/src/call.ts
+var call = async (method, params) => {
+  const shaKey = await _generateShaKey(JSON.stringify({ method, params }));
+  const cache = localStorage.getItem(shaKey);
+  if (cache !== null) {
+    const { data, expireDate } = JSON.parse(cache);
+    if (new Date(expireDate) > /* @__PURE__ */ new Date()) {
+      return JSON.parse(data);
+    } else {
+      localStorage.removeItem(shaKey);
+    }
+  }
+  const res = await fetch(`${process.env.NEXT_PUBLIC_API_URL}/api/rpc`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ method, params }),
+    credentials: "include"
+  });
+  const json = await res.json();
+  if (!res.ok) throw new Error(json.error || "Unknown error");
+  const today = /* @__PURE__ */ new Date();
+  const result = {
+    data: JSON.stringify(json.data),
+    expireDate: new Date(today.getTime() + 1e3 * 60 * 60)
+  };
+  localStorage.setItem(shaKey, JSON.stringify(result));
+  return json.data;
+};
+
+// ../utils/src/classMerge.ts
+var import_clsx = require("clsx");
+var import_tailwind_merge = require("tailwind-merge");
+
+// ../utils/src/params.ts
+var createParams = (fieldsList, key = "Fields") => fieldsList.map((item) => ({
+  key,
+  value: item
+}));
+var generateQueryParams = (params) => {
+  const queryParams = params.map(
+    (param) => `${encodeURIComponent(param.key)}=${encodeURIComponent(param.value)}`
+  ).join("&");
+  return queryParams;
+};
+
+// ../utils/src/renditions.ts
+var getFileRenditions = ({ renditions }) => {
+  if (renditions == void 0 || renditions.length == 0) {
+    return {
+      filesToDownload: [],
+      filesToOpen: []
+    };
+  }
+  const filteredRenditions = renditions.filter(
+    (item) => item.format != "application/xhtml+xml" && item.format != "application/json" && item.format != "application/llm+xml"
+  );
+  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/baseService.ts
 var BaseService = class {
   api;
@@ -281,7 +494,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,41 +520,6 @@ var RenditionsService = class extends BaseService {
     });
     return response;
   }
-  getFileRenditions = (renditions) => {
-    if (renditions == void 0 || renditions.length == 0) {
-      return {
-        filesToDownload: [],
-        filesToOpen: []
-      };
-    }
-    const filteredRenditions = renditions.filter(
-      (item) => item.format != "application/xhtml+xml" && item.format != "application/json" && item.format != "application/llm+xml"
-    );
-    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
@@ -341,11 +527,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 +576,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 = [
       {
@@ -395,11 +604,12 @@ var import_next_cookies2 = require("@c-rex/utils/next-cookies");
 var transformInformationUnits = async (data) => {
   const config = await (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 } = 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 +635,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 +677,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,32 +700,52 @@ 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);
-  }
-  /*
-      public static async getInstance(): Promise<LanguageService> {
-          const customerConfig = await getConfigs()
-  
-          if (!LanguageService.instance) {
-              LanguageService.instance = new LanguageService(customerConfig.languageSwitcher.endpoint);
-          }
-          return LanguageService.instance;
-      }
-      */
+  constructor() {
+    const configs = (0, import_next_cookies3.getConfigs)();
+    super(configs.languageSwitcher.endpoint);
+  }
+  /**
+   * 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) => {