@c-rex/services 0.1.3 → 0.1.5

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,6 +57,7 @@ var API = {
     "content-Type": "application/json"
   }
 };
+var SDK_CONFIG_KEY = "crex-sdk-config";
 var FLAGS_BY_LANG = {
   "en": "US",
   "de": "DE"
@@ -64,188 +73,153 @@ 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 WILD_CARD_OPTIONS = {
+  BOTH: "BOTH",
+  END: "END",
+  START: "START",
+  NONE: "NONE"
 };
-var getCountryCodeByLang = (lang) => {
-  const mappedKeys = Object.keys(FLAGS_BY_LANG);
-  if (!mappedKeys.includes(lang)) {
-    return lang;
-  }
-  const country = FLAGS_BY_LANG[lang];
-  return country;
+var OPERATOR_OPTIONS = {
+  AND: "AND",
+  OR: "OR"
 };
 
-// ../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/requests.ts
+var import_headers = require("next/headers");
+
+// ../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
+    });
+    this.matomoTransport = new import_winston_transport.default();
+    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
-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/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
+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
     });
-    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 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??
+        ]
+      }
     });
-    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
 var import_next_cookies = require("@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 (0, import_next_cookies.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 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)
+      ]
+    });
   }
 };
 
@@ -253,24 +227,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 (0, import_next_cookies.getConfigs)();
+      const aux = await (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");
+      }
     }
     if (!this.apiClient) {
       this.apiClient = import_axios.default.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 = (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;
     }
   }
   /**
@@ -295,7 +312,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}`
@@ -313,7 +330,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}`
         });
@@ -329,6 +346,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;
@@ -413,48 +530,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
@@ -536,21 +611,38 @@ var DocumentTypesService = class extends BaseService {
 
 // src/transforms/information.ts
 var import_next_cookies2 = require("@c-rex/utils/next-cookies");
+var import_logger2 = require("@c-rex/core/logger");
 var transformInformationUnits = async (data) => {
-  const config = (0, import_next_cookies2.getConfigs)();
+  const config = await (0, import_next_cookies2.getConfigs)();
+  const logger = new import_logger2.CrexLogger();
   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}`;
     } else if (type == RESULT_TYPES.DOCUMENT) {
       link = `/documents/${item.shortId}`;
     }
+    let title = "NO TITLE";
+    let language = "NO LANGUAGE";
+    try {
+      if (item.titles) {
+        title = item.titles[0].value;
+        language = item.titles[0].language;
+      } else {
+        title = item.labels[0].value;
+        language = item.labels[0].language;
+      }
+    } catch {
+      logger.log({
+        level: "error",
+        message: `No label or title on item ${item.shortId}`
+      });
+    }
     return {
-      language: item.labels[0].language,
-      title: item.labels[0].value,
+      language,
+      title,
       type,
       localeType: "",
       shortId: item.shortId,
@@ -560,11 +652,24 @@ var transformInformationUnits = async (data) => {
       filesToDownload
     };
   }));
+  const filteredList = items.filter((item) => item != null);
   return {
-    items,
+    items: filteredList,
     pageInfo: data.pageInfo
   };
 };
+var transformSuggestions = (data, query) => {
+  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/informationUnits.ts
 var InformationUnitsService = class extends BaseService {
@@ -588,20 +693,29 @@ var InformationUnitsService = class extends BaseService {
     page = 1,
     fields = [],
     filters = [],
-    languages = []
+    restrict = [],
+    languages = [],
+    wildcard = WILD_CARD_OPTIONS.BOTH,
+    operator = OPERATOR_OPTIONS.AND,
+    like = false
   }) {
     const remainFields = createParams(fields, "Fields");
     const remainFilters = createParams(filters, "Filter");
+    const restrictions = createParams(restrict, "Restrict");
     const languageParams = createParams(
-      languages.map((item) => `languages=${item}`),
-      "Filter"
+      languages.map((item) => `?s iirds:language '${item}'`),
+      "sparqlWhere"
     );
     const params = [
       { key: "pageSize", value: "12" },
+      { key: "wildcard", value: wildcard.toLowerCase() },
       { key: "PageNumber", value: page.toString() },
+      { key: "Operator", value: operator },
+      { key: "Like", value: like.toString() },
       ...remainFields,
       ...languageParams,
-      ...remainFilters
+      ...remainFilters,
+      ...restrictions
     ];
     if (queries.length > 0) {
       params.push(
@@ -629,7 +743,8 @@ var InformationUnitsService = class extends BaseService {
       { key: "Fields", value: "versionOf" },
       { key: "Fields", value: "titles" },
       { key: "Fields", value: "languages" },
-      { key: "Fields", value: "labels" }
+      { key: "Fields", value: "labels" },
+      { key: "Fields", value: "packages" }
     ];
     return await this.request({
       path: id,
@@ -647,23 +762,12 @@ var InformationUnitsService = class extends BaseService {
    */
   async getSuggestions({ query, language }) {
     return await this.request({
-      path: `Suggestions`,
+      path: "Suggestions",
       params: [
         { key: "prefix", value: query },
         { key: "lang", value: language }
       ],
-      transformer: (data) => {
-        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;
-      }
+      transformer: (data) => transformSuggestions(data, query)
     });
   }
 };
@@ -675,16 +779,6 @@ var LanguageService = class extends BaseService {
     const configs = (0, import_next_cookies3.getConfigs)();
     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.