@c-rex/core 0.1.13 → 0.1.14

package/dist/requests.js

@@ -0,0 +1,670 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/requests.ts
+var requests_exports = {};
+__export(requests_exports, {
+  CrexApi: () => CrexApi
+});
+module.exports = __toCommonJS(requests_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 SDK_CONFIG_KEY = "crex-sdk-config";
+var DEFAULT_COOKIE_LIMIT = 30 * 24 * 60 * 60 * 1e3;
+var CREX_TOKEN_HEADER_KEY = "crex-token";
+
+// src/requests.ts
+var import_headers2 = require("next/headers");
+
+// src/logger.ts
+var import_winston = __toESM(require("winston"));
+
+// 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;
+  }
+  /**
+   * 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);
+    }
+  }
+};
+
+// 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) {
+    if (!configs.logs.graylog.hostname || configs.logs.graylog.port === void 0) {
+      throw new Error("Graylog hostname and port must be defined");
+    }
+    super({
+      level: configs.logs.graylog.minimumLevel,
+      silent: configs.logs.graylog.silent
+    });
+    this.configs = configs;
+    this.graylogTransport = new import_winston_graylog2.default({
+      name: configs.logs.graylog.app,
+      silent: configs.logs.graylog.silent,
+      handleExceptions: false,
+      graylog: {
+        servers: [
+          { host: configs.logs.graylog.hostname, port: configs.logs.graylog.port }
+        ]
+      }
+    });
+  }
+  /**
+   * 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);
+    }
+  }
+};
+
+// src/utils.ts
+var formatIssuer = (issuer) => {
+  let newIssuer = issuer;
+  const lastChar = newIssuer.charAt(newIssuer.length - 1);
+  if (lastChar !== "/") {
+    newIssuer += "/";
+  }
+  newIssuer += ".well-known/openid-configuration";
+  return newIssuer;
+};
+var formatApiUrl = (apiUrl) => {
+  let newApiUrl = apiUrl;
+  const lastChar = newApiUrl.charAt(newApiUrl.length - 1);
+  if (lastChar !== "/") {
+    newApiUrl += "/";
+  }
+  newApiUrl += "iirds/v1/";
+  return newApiUrl;
+};
+var mergeConfigs = (defaultConfig, envVars) => {
+  const definedEnvVars = {};
+  for (const key in envVars) {
+    if (envVars[key] !== void 0) {
+      definedEnvVars[key] = envVars[key];
+    }
+  }
+  return {
+    ...defaultConfig,
+    ...definedEnvVars
+  };
+};
+var generateWarnings = (vars) => {
+  const warnings = [];
+  vars.forEach((variable) => {
+    const value = process.env[variable.key];
+    if (value === void 0) {
+      warnings.push(`Missing environment variable ${variable.key}, using default value: ${variable.default}`);
+    }
+  });
+  return warnings;
+};
+var createUserOIDCConfig = () => {
+  const warnings = [];
+  const userDefaults = {
+    secret: "dummy",
+    scope: "openid profile crex.ids.api crex.ids.api.public",
+    enabled: true
+  };
+  const userEnvs = {
+    id: process.env.CREX_IDS_ID,
+    secret: process.env.CREX_IDS_SECRET,
+    scope: process.env.CREX_IDS_USER_SCOPES,
+    issuer: process.env.CREX_IDS_ISSUER == void 0 ? void 0 : formatIssuer(process.env.CREX_IDS_ISSUER),
+    enabled: process.env.CREX_IDS_USER_LOGIN_ENABLE == void 0 ? void 0 : process.env.CREX_IDS_USER_LOGIN_ENABLE == "true"
+  };
+  const user = mergeConfigs(userDefaults, userEnvs);
+  if (user.enabled) {
+    const disableOIDCVars = [
+      { key: "CREX_IDS_ID", value: process.env.CREX_IDS_ID },
+      { key: "CREX_IDS_ISSUER", value: process.env.CREX_IDS_ISSUER }
+    ];
+    disableOIDCVars.forEach((variable) => {
+      if (variable.value === void 0) {
+        user.enabled = false;
+        warnings.push(`Missing environment variable ${variable.key}, disabling client and login`);
+      }
+    });
+  }
+  if (user.enabled) {
+    const userWarningVars = [
+      { key: "CREX_IDS_USER_SCOPES", default: user.scope },
+      { key: "CREX_IDS_SECRET", default: user.secret },
+      { key: "CREX_IDS_USER_LOGIN_ENABLE", default: user.enabled }
+    ];
+    const aux = generateWarnings(userWarningVars);
+    warnings.push(...aux);
+  }
+  return { user, warnings };
+};
+var createClientOIDCConfig = () => {
+  const warnings = [];
+  const clientDefault = {
+    secret: "dummy",
+    enabled: true
+  };
+  const clientEnvs = {
+    id: process.env.CREX_IDS_ID,
+    issuer: process.env.CREX_IDS_ISSUER == void 0 ? void 0 : formatIssuer(process.env.CREX_IDS_ISSUER),
+    secret: process.env.CREX_IDS_SECRET,
+    enabled: process.env.CREX_IDS_CLIENT_LOGIN_ENABLE == void 0 ? void 0 : process.env.CREX_IDS_CLIENT_LOGIN_ENABLE == "true"
+  };
+  const client = mergeConfigs(clientDefault, clientEnvs);
+  if (client.enabled) {
+    const disableOIDCVars = [
+      { key: "CREX_IDS_ID", value: process.env.CREX_IDS_ID },
+      { key: "CREX_IDS_ISSUER", value: process.env.CREX_IDS_ISSUER }
+    ];
+    disableOIDCVars.forEach((variable) => {
+      if (variable.value === void 0) {
+        client.enabled = false;
+        warnings.push(`Missing environment variable ${variable.key}, disabling client and login`);
+      }
+    });
+  }
+  if (client.enabled) {
+    const clientWarningVars = [
+      { key: "CREX_IDS_SECRET", default: client.secret },
+      { key: "CREX_IDS_CLIENT_LOGIN_ENABLE", default: client.enabled }
+    ];
+    const aux = generateWarnings(clientWarningVars);
+    warnings.push(...aux);
+  }
+  return { client, warnings };
+};
+var createConsoleLoggerConfig = () => {
+  const warnings = [];
+  const consoleLoggerDefaults = {
+    minimumLevel: "info",
+    silent: false
+  };
+  const consoleLoggerEnvs = {
+    minimumLevel: process.env.LOG_CONSOLE_LEVEL,
+    silent: process.env.LOG_CONSOLE_SILENT == void 0 ? void 0 : process.env.LOG_CONSOLE_SILENT == "true"
+  };
+  const consoleLogger = mergeConfigs(consoleLoggerDefaults, consoleLoggerEnvs);
+  if (consoleLogger.silent == false) {
+    const consoleWarningsVars = [
+      { key: "LOG_CONSOLE_SILENT", default: consoleLogger.silent },
+      { key: "LOG_CONSOLE_LEVEL", default: consoleLogger.minimumLevel }
+    ];
+    const aux = generateWarnings(consoleWarningsVars);
+    warnings.push(...aux);
+  }
+  return {
+    consoleLogger,
+    warnings
+  };
+};
+var createGraylogLoggerConfig = () => {
+  const warnings = [];
+  const graylogDefaults = {
+    app: "app name not set",
+    minimumLevel: "info",
+    silent: false,
+    hostname: "https://log.c-rex.net",
+    port: 12202,
+    categoriesLevel: ["NoLicense", "Scenario", "Document", "Search", "Notification", "History", "UserProfile"]
+  };
+  const graylogEnvs = {
+    app: process.env.LOG_GRAYLOG_APP_NAME,
+    silent: process.env.LOG_GRAYLOG_SILENT == void 0 ? void 0 : process.env.LOG_GRAYLOG_SILENT == "true",
+    hostname: process.env.LOG_GRAYLOG_HOSTNAME,
+    port: process.env.LOG_GRAYLOG_PORT == void 0 ? void 0 : Number(process.env.LOG_GRAYLOG_PORT),
+    minimumLevel: process.env.LOG_GRAYLOG_LEVEL,
+    categoriesLevel: process.env.LOG_GRAYLOG_CATEGORIES == void 0 ? void 0 : process.env.LOG_GRAYLOG_CATEGORIES.split(",")
+  };
+  const graylog = mergeConfigs(graylogDefaults, graylogEnvs);
+  if (graylog.silent == false) {
+    const graylogWarningVars = [
+      { key: "LOG_GRAYLOG_APP_NAME", default: graylog.app },
+      { key: "LOG_GRAYLOG_HOSTNAME", default: graylog.hostname },
+      { key: "LOG_GRAYLOG_LEVEL", default: graylog.minimumLevel },
+      { key: "LOG_GRAYLOG_SILENT", default: graylog.silent },
+      { key: "LOG_GRAYLOG_CATEGORIES", default: graylog.categoriesLevel },
+      { key: "LOG_GRAYLOG_PORT", default: graylog.port }
+    ];
+    const aux = generateWarnings(graylogWarningVars);
+    warnings.push(...aux);
+  }
+  return {
+    graylog,
+    warnings
+  };
+};
+var createMatomoLoggerConfig = () => {
+  const warnings = [];
+  const matomoDefaults = {
+    app: "NextJsProjectName",
+    minimumLevel: "info",
+    silent: true,
+    hostname: "",
+    port: 0,
+    categoriesLevel: ["NoLicense", "Scenario", "Document", "Search", "Notification", "History", "UserProfile"]
+  };
+  const matomoEnvs = {
+    app: process.env.LOG_MATOMO_APP_NAME,
+    silent: process.env.LOG_MATOMO_SILENT == void 0 ? void 0 : process.env.LOG_MATOMO_SILENT == "true",
+    hostname: process.env.LOG_MATOMO_HOSTNAME,
+    port: process.env.LOG_MATOMO_PORT == void 0 ? void 0 : Number(process.env.LOG_MATOMO_PORT),
+    minimumLevel: process.env.LOG_MATOMO_LEVEL,
+    categoriesLevel: process.env.LOG_MATOMO_CATEGORIES == void 0 ? void 0 : process.env.LOG_MATOMO_CATEGORIES.split(",")
+  };
+  const matomo = mergeConfigs(matomoDefaults, matomoEnvs);
+  const matomoSilentVars = [
+    { key: "LOG_MATOMO_SILENT", value: process.env.LOG_MATOMO_SILENT },
+    { key: "LOG_MATOMO_HOSTNAME", value: process.env.LOG_MATOMO_HOSTNAME },
+    { key: "LOG_MATOMO_PORT", value: process.env.LOG_MATOMO_PORT }
+  ];
+  matomoSilentVars.forEach((variable) => {
+    if (variable.value === void 0) {
+      matomo.silent = true;
+      warnings.push(`Missing environment variable ${variable.key}, setting matomo logger to silent`);
+    }
+  });
+  if (matomo.silent == false) {
+    const matomoWarningVars = [
+      { key: "LOG_MATOMO_APP_NAME", default: matomo.app },
+      { key: "LOG_MATOMO_LEVEL", default: matomo.minimumLevel },
+      { key: "LOG_MATOMO_CATEGORIES", default: matomo.categoriesLevel }
+    ];
+    const aux = generateWarnings(matomoWarningVars);
+    warnings.push(...aux);
+  }
+  return {
+    matomo,
+    warnings
+  };
+};
+
+// src/sdk.ts
+var import_headers = require("next/headers");
+var CrexSDK = class {
+  userAuthConfig;
+  customerConfig;
+  cookiesConfig;
+  async getUserAuthConfig() {
+    if (this.userAuthConfig) {
+      return this.userAuthConfig;
+    }
+    if (!this.customerConfig) {
+      this.customerConfig = this.getServerConfig();
+    }
+    const user = this.customerConfig.OIDC.user;
+    const userInfoEndPoint = this.customerConfig.OIDC.issuerMetadata?.userinfo_endpoint;
+    if (user.enabled) {
+      this.userAuthConfig = {
+        providers: [
+          {
+            id: "crex",
+            name: "CREX",
+            type: "oauth",
+            version: "2.0",
+            clientId: user.id,
+            wellKnown: user.issuer,
+            clientSecret: user.secret,
+            authorization: {
+              params: {
+                scope: user.scope,
+                prompt: "login"
+              }
+            },
+            idToken: true,
+            checks: ["pkce", "state"],
+            async profile(_, tokens) {
+              const res = await fetch(userInfoEndPoint, {
+                headers: {
+                  Authorization: `Bearer ${tokens.access_token}`
+                }
+              });
+              const userinfo = await res.json();
+              return {
+                id: userinfo.sub,
+                name: userinfo.name,
+                email: userinfo.email
+              };
+            },
+            callbacks: {
+              async jwt({ token, account }) {
+                if (account) {
+                  token.id_token = account.id_token;
+                }
+                return token;
+              },
+              async session({ session, token }) {
+                session.id_token = token.id_token;
+                return session;
+              }
+            }
+          }
+        ]
+      };
+    }
+    ;
+    return this.userAuthConfig;
+  }
+  createCustomerConfig(CUSTOMER_CONFIG, shouldLog) {
+    const requiredEnvVars = ["CREX_API_URL", "NEXT_PUBLIC_API_URL"];
+    const required = requiredEnvVars.map((key) => {
+      const value = process.env[key];
+      if (value === void 0) {
+        return `Missing required environment variable: ${key}`;
+      }
+      return "";
+    }).filter((item) => item.length > 0);
+    const { user, warnings: userWarnings } = createUserOIDCConfig();
+    const { client, warnings: clientWarnings } = createClientOIDCConfig();
+    const { matomo, warnings: matomoWarnings } = createMatomoLoggerConfig();
+    const { graylog, warnings: graylogWarnings } = createGraylogLoggerConfig();
+    const { consoleLogger, warnings: consoleWarnings } = createConsoleLoggerConfig();
+    const warnings = required.concat(
+      consoleWarnings,
+      clientWarnings,
+      userWarnings,
+      graylogWarnings,
+      matomoWarnings
+    );
+    if (shouldLog) {
+      if (warnings.length > 0) console.warn(warnings.join("\n"));
+    }
+    const cookiesConfig = {
+      publicNextApiUrl: process.env.NEXT_PUBLIC_API_URL,
+      ...CUSTOMER_CONFIG,
+      OIDC: {
+        clientEnabled: client.enabled,
+        userEnabled: user.enabled
+      }
+    };
+    const config = {
+      baseUrl: process.env.CREX_API_URL == void 0 ? "" : formatApiUrl(process.env.CREX_API_URL),
+      OIDC: { client, user },
+      logs: { console: consoleLogger, graylog, matomo },
+      ...CUSTOMER_CONFIG
+    };
+    return { cookiesConfig, config };
+  }
+  getClientConfig = () => {
+    const jsonConfigs = (0, import_headers.cookies)().get(SDK_CONFIG_KEY)?.value;
+    if (!jsonConfigs) {
+      throw new Error("Configs not found");
+    }
+    const configs = JSON.parse(jsonConfigs);
+    return configs;
+  };
+  getServerConfig() {
+    if (!global.__GLOBAL_CONFIG__) {
+      throw new Error("Server config not initialized");
+    }
+    return global.__GLOBAL_CONFIG__;
+  }
+  initializeConfig(config) {
+    if (global.__GLOBAL_CONFIG__) return global.__GLOBAL_CONFIG__;
+    global.__GLOBAL_CONFIG__ = config;
+    return global.__GLOBAL_CONFIG__;
+  }
+  updateConfigProp(key, value) {
+    if (!global.__GLOBAL_CONFIG__) {
+      throw new Error("Server config not initialized");
+    }
+    global.__GLOBAL_CONFIG__[key] = value;
+    return global.__GLOBAL_CONFIG__;
+  }
+};
+
+// src/logger.ts
+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) {
+        const sdk = new CrexSDK();
+        this.customerConfig = sdk.getServerConfig();
+      }
+      if (!this.logger) {
+        this.logger = this.createLogger();
+      }
+    } catch (error) {
+      console.log("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();
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const newMessage = `[${timestamp}] ${message}`;
+    this.logger.log(level, newMessage, 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)
+      ]
+    });
+  }
+};
+
+// src/OIDC.ts
+var import_openid_client = require("openid-client");
+var getToken = async () => {
+  try {
+    const sdk = new CrexSDK();
+    const config = sdk.getServerConfig();
+    const issuer = await import_openid_client.Issuer.discover(config.OIDC.client.issuer);
+    const client = new issuer.Client({
+      client_id: config.OIDC.client.id,
+      client_secret: config.OIDC.client.secret
+    });
+    const tokenSet = await client.grant({ grant_type: "client_credentials" });
+    const token = tokenSet.access_token;
+    const expiresAt = tokenSet.expires_at;
+    return { token, expiresAt };
+  } catch (error) {
+    const logger = new CrexLogger();
+    logger.log({
+      level: "error",
+      message: `getToken error: ${error}`
+    });
+    return { token: "", expiresAt: 0, error: JSON.stringify(error) };
+  }
+};
+
+// src/requests.ts
+var CrexApi = class {
+  customerConfig;
+  apiClient;
+  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 sdk = new CrexSDK();
+      this.customerConfig = sdk.getServerConfig();
+    }
+    if (!this.apiClient) {
+      if (this.customerConfig.baseUrl.length === 0) {
+        throw new Error("CrexAPI.initAPI error: baseUrl is undefined");
+      }
+      this.apiClient = import_axios.default.create({
+        baseURL: this.customerConfig.baseUrl
+      });
+    }
+  }
+  async manageToken() {
+    try {
+      let token = "";
+      const hasToken = (0, import_headers2.cookies)().get(CREX_TOKEN_HEADER_KEY);
+      if (hasToken == void 0 || hasToken.value === null) {
+        const { token: tokenResult } = await getToken();
+        if (tokenResult.length === 0) throw new Error("Token is undefined");
+        token = tokenResult;
+      } else {
+        token = hasToken.value;
+      }
+      return token;
+    } catch (error) {
+      this.logger.log({
+        level: "error",
+        message: `CrexAPI.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,
+    params,
+    body,
+    headers = {}
+  }) {
+    try {
+      await this.initAPI();
+      let response = void 0;
+      if (this.customerConfig.OIDC.client.enabled) {
+        const token = await this.manageToken();
+        headers = {
+          ...headers,
+          Authorization: `Bearer ${token}`
+        };
+        this.apiClient.defaults.headers.common["Authorization"] = `Bearer ${token}`;
+      }
+      response = await this.apiClient.request({
+        url,
+        method,
+        data: body,
+        params,
+        headers
+      });
+      if (response) {
+        return response.data;
+      }
+      throw new Error("API.execute error: Failed to retrieve a valid response");
+    } catch (error) {
+      this.logger.log({
+        level: "error",
+        message: `CrexAPI.execute error: ${error}`
+      });
+      throw error;
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CrexApi
+});
+//# sourceMappingURL=requests.js.map