@c-rex/services 0.1.3 → 0.1.4

package/dist/index.mjs

@@ -2,6 +2,14 @@
 import axios from "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,
@@ -9,6 +17,7 @@ var API = {
     "content-Type": "application/json"
   }
 };
+var SDK_CONFIG_KEY = "crex-sdk-config";
 var FLAGS_BY_LANG = {
   "en": "US",
   "de": "DE"
@@ -25,187 +34,142 @@ var RESULT_TYPES = {
 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) => {
-  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 }),
-      credentials: "include"
-    });
-    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;
-  }
-};
-var getCountryCodeByLang = (lang) => {
-  const mappedKeys = Object.keys(FLAGS_BY_LANG);
-  if (!mappedKeys.includes(lang)) {
-    return lang;
-  }
-  const country = FLAGS_BY_LANG[lang];
-  return country;
-};
+// ../core/src/requests.ts
+import { cookies } from "next/headers";
+
+// ../core/src/logger.ts
+import winston from "winston";
 
-// ../utils/src/memory.ts
-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 };
+// ../core/src/transports/matomo.ts
+import Transport from "winston-transport";
+var MatomoTransport = class extends Transport {
+  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
+    });
+    this.matomoTransport = new Transport();
+    this.configs = configs;
   }
-  const json = await res.json();
-  return json;
-};
-var setCookie = async (key, value, maxAge) => {
-  try {
-    if (maxAge === void 0) {
-      maxAge = DEFAULT_COOKIE_LIMIT;
+  /**
+   * 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);
     }
-    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}`
-    });
   }
 };
 
-// ../utils/src/classMerge.ts
-import { clsx } from "clsx";
-import { twMerge } from "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/token.ts
-var updateToken = async () => {
-  try {
-    const response = await fetch(`${process.env.NEXT_PUBLIC_API_URL}/api/token`, {
-      method: "POST",
-      credentials: "include"
+// ../core/src/transports/graylog.ts
+import Transport2 from "winston-transport";
+import Graylog2Transport from "winston-graylog2";
+var GraylogTransport = class extends Transport2 {
+  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
     });
-    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}`
+    this.configs = configs;
+    this.graylogTransport = new Graylog2Transport({
+      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??
+        ]
+      }
     });
-    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;
+  /**
+   * 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);
     }
-    return token;
-  } catch (error) {
-    call("CrexLogger.log", {
-      level: "error",
-      message: `utils.manageToken error: ${error}`
-    });
-    return null;
   }
 };
 
-// ../core/src/requests.ts
+// ../core/src/logger.ts
 import { getConfigs } from "@c-rex/utils/next-cookies";
-
-// ../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;
-  }
+var CrexLogger = class {
+  customerConfig;
+  logger;
   /**
-   * Stores a value in the cache with the specified key.
-   * Checks if the value size is within cookie size limits (4KB).
+   * Initializes the logger instance if it hasn't been initialized yet.
+   * Loads customer configuration and creates the logger with appropriate transports.
    * 
-   * @param key - The cache key
-   * @param value - The value to store
+   * @private
    */
-  async set(key, value) {
+  async initLogger() {
     try {
-      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`);
+      if (!this.customerConfig) {
+        this.customerConfig = await getConfigs();
+      }
+      if (!this.logger) {
+        this.logger = this.createLogger();
       }
     } catch (error) {
-      call("CrexLogger.log", {
-        level: "error",
-        message: `CrexCache.set error: ${error}`
-      });
+      console.error("Error initializing logger:", error);
     }
   }
   /**
-   * Generates a cache key based on request parameters.
-   * Combines URL, method, and optionally params, body, and headers into a single string key.
+   * Logs a message with the specified level and optional category.
    * 
-   * @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
+   * @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
    */
-  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;
+  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 winston.createLogger({
+      levels: LOG_LEVELS,
+      transports: [
+        new winston.transports.Console({
+          level: this.customerConfig.logs.console.minimumLevel,
+          silent: this.customerConfig.logs.console.silent
+        }),
+        new MatomoTransport(this.customerConfig),
+        new GraylogTransport(this.customerConfig)
+      ]
+    });
   }
 };
 
@@ -213,24 +177,67 @@ var CrexCache = class {
 var CrexApi = class {
   customerConfig;
   apiClient;
-  cache;
+  logger;
   /**
    * Initializes the API client if it hasn't been initialized yet.
-   * Loads customer configuration, creates the axios instance, and initializes the cache.
+   * Loads customer configuration, creates the axios instance, and initializes the logger.
    * 
    * @private
    */
   async initAPI() {
+    this.logger = new CrexLogger();
     if (!this.customerConfig) {
-      this.customerConfig = await getConfigs();
+      const aux = 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");
+      }
     }
     if (!this.apiClient) {
       this.apiClient = axios.create({
         baseURL: this.customerConfig.baseUrl
       });
     }
-    if (!this.cache) {
-      this.cache = new CrexCache();
+  }
+  async getToken() {
+    try {
+      const response = await fetch(`${process.env.NEXT_PUBLIC_API_URL}/api/token`, {
+        method: "POST",
+        credentials: "include"
+      });
+      const { token } = await response.json();
+      return token;
+    } catch (error) {
+      this.logger.log({
+        level: "error",
+        message: `utils.getToken error: ${error}`
+      });
+      throw error;
+    }
+  }
+  async manageToken() {
+    try {
+      let token = "";
+      const hasToken = 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;
     }
   }
   /**
@@ -255,7 +262,7 @@ var CrexApi = class {
     await this.initAPI();
     let response = void 0;
     if (this.customerConfig.OIDC.client.enabled) {
-      const token = await manageToken();
+      const token = await this.manageToken();
       headers = {
         ...headers,
         Authorization: `Bearer ${token}`
@@ -273,7 +280,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}`
         });
@@ -289,6 +296,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
+import { clsx } from "clsx";
+import { twMerge } from "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;
@@ -373,48 +480,6 @@ var RenditionsService = class extends BaseService {
     });
     return response;
   }
-  /**
-   * 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(
-      (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
@@ -497,11 +562,10 @@ var DocumentTypesService = class extends BaseService {
 // src/transforms/information.ts
 import { getConfigs as getConfigs2 } from "@c-rex/utils/next-cookies";
 var transformInformationUnits = async (data) => {
-  const config = getConfigs2();
+  const config = await getConfigs2();
   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 });
+    const { filesToOpen, filesToDownload } = getFileRenditions({ renditions: item?.renditions });
     let link = `/topics/${item.shortId}`;
     if (config.results.articlePageLayout == "BLOG") {
       link = `/blog/${item.shortId}`;
@@ -635,16 +699,6 @@ var LanguageService = class extends BaseService {
     const configs = getConfigs3();
     super(configs.languageSwitcher.endpoint);
   }
-  /*
-      public static async getInstance(): Promise<LanguageService> {
-          const customerConfig = await getConfigs()
-  
-          if (!LanguageService.instance) {
-              LanguageService.instance = new LanguageService(customerConfig.languageSwitcher.endpoint);
-          }
-          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.