@c-rex/api 0.1.14

package/dist/index.d.mts

@@ -0,0 +1,39 @@
+import { NextRequest, NextResponse } from 'next/server';
+
+/**
+ * Retrieves a cookie value by key from the request
+ * @param {NextRequest} req - The Next.js request object
+ * @returns {Promise<NextResponse>} JSON response containing the cookie key-value pair or error
+ */
+declare const getCookieFromServer: (req: NextRequest) => Promise<NextResponse>;
+/**
+ * Sets a cookie with the specified key, value and options
+ * @param {NextRequest} req - The Next.js request object
+ * @returns {Promise<NextResponse>} JSON response indicating success or error
+ * @throws {Error} If key or value are missing in the request body
+ */
+declare const saveCookie: (req: NextRequest) => Promise<NextResponse>;
+
+/**
+ * Retrieves an access token using client credentials flow from the configured OIDC provider
+ *
+ * @returns NextResponse with success status or error message
+ * @throws Error if token retrieval fails
+ */
+declare const getTokenMethod: () => Promise<NextResponse>;
+declare const discoverIssuerMethod: () => Promise<NextResponse>;
+
+/**
+ * Handles POST requests for RPC (Remote Procedure Call) functionality.
+ * Allows calling methods on registered services with parameters.
+ *
+ * @param req - The Next.js request object containing the RPC payload
+ * @returns A JSON response with the result of the method call, or an error if the service or method is not found
+ */
+declare const POST: (req: NextRequest) => Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    data: any;
+}>>;
+
+export { POST, discoverIssuerMethod, getCookieFromServer, getTokenMethod, saveCookie };

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+import { NextRequest, NextResponse } from 'next/server';
+
+/**
+ * Retrieves a cookie value by key from the request
+ * @param {NextRequest} req - The Next.js request object
+ * @returns {Promise<NextResponse>} JSON response containing the cookie key-value pair or error
+ */
+declare const getCookieFromServer: (req: NextRequest) => Promise<NextResponse>;
+/**
+ * Sets a cookie with the specified key, value and options
+ * @param {NextRequest} req - The Next.js request object
+ * @returns {Promise<NextResponse>} JSON response indicating success or error
+ * @throws {Error} If key or value are missing in the request body
+ */
+declare const saveCookie: (req: NextRequest) => Promise<NextResponse>;
+
+/**
+ * Retrieves an access token using client credentials flow from the configured OIDC provider
+ *
+ * @returns NextResponse with success status or error message
+ * @throws Error if token retrieval fails
+ */
+declare const getTokenMethod: () => Promise<NextResponse>;
+declare const discoverIssuerMethod: () => Promise<NextResponse>;
+
+/**
+ * Handles POST requests for RPC (Remote Procedure Call) functionality.
+ * Allows calling methods on registered services with parameters.
+ *
+ * @param req - The Next.js request object containing the RPC payload
+ * @returns A JSON response with the result of the method call, or an error if the service or method is not found
+ */
+declare const POST: (req: NextRequest) => Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    data: any;
+}>>;
+
+export { POST, discoverIssuerMethod, getCookieFromServer, getTokenMethod, saveCookie };

package/dist/index.js

@@ -0,0 +1,553 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  POST: () => POST,
+  discoverIssuerMethod: () => discoverIssuerMethod,
+  getCookieFromServer: () => getCookieFromServer,
+  getTokenMethod: () => getTokenMethod,
+  saveCookie: () => saveCookie
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/cookies.ts
+var import_server = require("next/server");
+var import_headers = require("next/headers");
+
+// ../constants/src/index.ts
+var CONTENT_LANG_KEY = "CONTENT_LANG_KEY";
+var FLAGS_BY_LANG = {
+  "en": "US",
+  "de": "DE"
+};
+var EN_LANG = "en";
+var TOPIC = "TOPIC";
+var DOCUMENT = "DOCUMENT";
+var PACKAGE = "PACKAGE";
+var FRAGMENT = "FRAGMENT";
+var RESULT_TYPES = {
+  TOPIC,
+  DOCUMENT,
+  PACKAGE,
+  FRAGMENT
+};
+var DEFAULT_COOKIE_LIMIT = 30 * 24 * 60 * 60 * 1e3;
+var CREX_TOKEN_HEADER_KEY = "crex-token";
+var WILD_CARD_OPTIONS = {
+  BOTH: "BOTH",
+  END: "END",
+  START: "START",
+  NONE: "NONE"
+};
+var OPERATOR_OPTIONS = {
+  AND: "AND",
+  OR: "OR"
+};
+
+// src/cookies.ts
+var getCookieFromServer = async (req) => {
+  const key = req.nextUrl.searchParams.get("key");
+  if (!key) return import_server.NextResponse.json({ error: "Missing key" }, { status: 400 });
+  const value = (0, import_headers.cookies)().get(key);
+  const response = import_server.NextResponse.json({ key, value: value?.value || null });
+  return response;
+};
+var saveCookie = async (req) => {
+  const { key, value, maxAge: maxAgeAux } = await req.json();
+  let maxAge = maxAgeAux;
+  if (!key || value === void 0) {
+    return import_server.NextResponse.json({ error: "Missing key or value" }, { status: 400 });
+  }
+  if (maxAge === void 0) {
+    maxAge = DEFAULT_COOKIE_LIMIT;
+  }
+  const response = import_server.NextResponse.json({ success: true });
+  response.cookies.set({
+    name: key,
+    value,
+    secure: process.env.NODE_ENV === "production",
+    sameSite: "lax",
+    path: "/",
+    maxAge
+  });
+  return response;
+};
+
+// src/OIDC.ts
+var import_server2 = require("next/server");
+var import_OIDC = require("@c-rex/core/OIDC");
+var import_sdk = require("@c-rex/core/sdk");
+var getTokenMethod = async () => {
+  try {
+    const { token, expiresAt, error } = await (0, import_OIDC.getToken)();
+    if (error) {
+      return import_server2.NextResponse.json({ error }, { status: 500 });
+    }
+    const response = import_server2.NextResponse.json({ token });
+    response.cookies.set({
+      name: CREX_TOKEN_HEADER_KEY,
+      value: token,
+      httpOnly: true,
+      secure: process.env.NODE_ENV === "production",
+      sameSite: "lax",
+      path: "/",
+      expires: expiresAt ? new Date(expiresAt * 1e3) : void 0
+    });
+    return response;
+  } catch (error) {
+    return import_server2.NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+};
+var discoverIssuerMethod = async () => {
+  try {
+    const metadata = await (0, import_OIDC.getIssuerMetadata)();
+    const sdk = new import_sdk.CrexSDK();
+    const config = sdk.getServerConfig();
+    sdk.updateConfigProp("OIDC", {
+      ...config.OIDC,
+      issuerMetadata: metadata
+    });
+    const response = import_server2.NextResponse.json({ issuerMetadata: metadata });
+    return response;
+  } catch (error) {
+    return import_server2.NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+};
+
+// src/rpc.ts
+var import_logger3 = require("@c-rex/core/logger");
+
+// ../services/src/baseService.ts
+var import_requests = require("@c-rex/core/requests");
+
+// ../utils/src/utils.ts
+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/classMerge.ts
+var import_clsx = require("clsx");
+var import_tailwind_merge = require("tailwind-merge");
+
+// ../utils/src/params.ts
+var createParams = (fieldsList, key = "Fields") => {
+  if (!fieldsList || fieldsList.length === 0) {
+    return [];
+  }
+  return 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 {};
+  }
+  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 {};
+  }
+  const result = {};
+  filteredRenditions.forEach((item) => {
+    const key = item.format;
+    if (result[key] == void 0) {
+      result[key] = {
+        view: "",
+        download: ""
+      };
+    }
+    result[key].download = item.links.filter((link) => link.rel == "download")[0]?.href;
+    result[key].view = item.links.filter((link) => link.rel == "view")[0]?.href;
+  });
+  return result;
+};
+
+// ../services/src/baseService.ts
+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 import_requests.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",
+    params = [],
+    headers = {},
+    transformer = (response) => response
+  }) {
+    let url = `${this.endpoint}${path}`;
+    const queryParams = generateQueryParams(params);
+    if (queryParams.length > 0) {
+      url += `?${queryParams}`;
+    }
+    const response = await this.api.execute({
+      url,
+      method,
+      headers
+    });
+    return await transformer(response);
+  }
+};
+
+// ../services/src/transforms/documentTypes.ts
+var import_sdk2 = require("@c-rex/core/sdk");
+var import_headers2 = require("next/headers");
+
+// ../services/src/transforms/information.ts
+var import_headers3 = require("next/headers");
+var import_logger = require("@c-rex/core/logger");
+var import_sdk3 = require("@c-rex/core/sdk");
+var transformInformationUnits = async (data) => {
+  const logger = new import_logger.CrexLogger();
+  const sdk = new import_sdk3.CrexSDK();
+  const frontEndConfig = sdk.getClientConfig();
+  const backEndConfig = sdk.getServerConfig();
+  const filteredTags = {};
+  const items = data.items.map((item) => {
+    const type = item.class.labels.filter((item2) => item2.language === EN_LANG)[0].value.toUpperCase();
+    const files = getFileRenditions({ renditions: item?.renditions });
+    let link = `/topics/${item.shortId}`;
+    if (frontEndConfig.results.articlePageLayout == "BLOG") {
+      link = `/blog/${item.shortId}`;
+    } else if (type == RESULT_TYPES.DOCUMENT) {
+      link = `/documents/${item.shortId}`;
+    }
+    let title = "NO TITLE";
+    if (item.titles) {
+      title = item.titles[0].value;
+    } else if (item.labels) {
+      title = item.labels[0].value;
+    }
+    let language = "NO LANGUAGE";
+    if (item.languages.length > 0) {
+      language = item.languages[0];
+    }
+    let versionOf = [];
+    if (item?.versionOf && item.versionOf?.labels) {
+      versionOf = item.versionOf.labels.map((item2) => item2.language).filter((value) => value !== void 0);
+    }
+    return {
+      language,
+      title,
+      type,
+      localeType: "",
+      revision: item.revision,
+      shortId: item.shortId,
+      multipleVersions: versionOf,
+      disabled: frontEndConfig.results.disabledResults.includes(type),
+      link,
+      files
+    };
+  });
+  if (data.tags) {
+    const contentLang = ((0, import_headers3.cookies)().get(CONTENT_LANG_KEY)?.value || EN_LANG).toLowerCase();
+    const splittedContentLang = contentLang.split("-")[0];
+    for (const [key, value] of Object.entries(data.tags)) {
+      if (!value || !value.items || value.items.length === 0) {
+        continue;
+      }
+      if (!backEndConfig.search.tags.includes(key)) {
+        continue;
+      }
+      const aux = value.items.map((item) => {
+        if (item?.shortId === void 0) return null;
+        if (Number(item.hits) === 0) return null;
+        if (item?.labels === void 0 || item?.labels.length === 0) {
+          logger.log({
+            level: "warning",
+            message: `No labels on item with id ${item.shortId} from category ${key}`
+          });
+          return null;
+        }
+        let label = "";
+        for (const labelItem of item.labels) {
+          if (labelItem.language === void 0) {
+            logger.log({
+              level: "info",
+              message: `No language on label ${labelItem.value} from category ${key}`
+            });
+            label = labelItem.value;
+            break;
+          }
+          if (labelItem.language.toLowerCase() === contentLang || labelItem.language.toLowerCase() === splittedContentLang) {
+            label = labelItem.value;
+            break;
+          }
+          label = labelItem.value;
+        }
+        return {
+          hits: item.hits,
+          total: item.total,
+          label,
+          active: false,
+          shortId: item.shortId
+        };
+      }).filter((item) => item !== null);
+      if (aux.length === 0) {
+        continue;
+      }
+      filteredTags[key] = aux;
+    }
+  }
+  return {
+    tags: filteredTags,
+    items,
+    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;
+};
+
+// ../services/src/informationUnits.ts
+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,
+    fields = [],
+    filters = [],
+    tags = [],
+    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 remainTags = createParams(tags, "Tags");
+    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() },
+      ...remainTags,
+      ...remainFields,
+      ...remainFilters,
+      ...restrictions
+    ];
+    if (languages.length > 0) {
+      const languageParam = `VALUES ?lang { ${languages.map((lang) => `"${lang}"`).join(" ")} } ?s iirds:language ?lang .`;
+      params.push({ key: "sparqlWhere", value: languageParam });
+    }
+    if (queries.length > 0) {
+      params.push(
+        { key: "Query", value: queries }
+      );
+    }
+    return await this.request({
+      params,
+      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, shouldGetAllFields = false }) {
+    const params = [];
+    if (!shouldGetAllFields) {
+      params.push(
+        { key: "Fields", value: "renditions" },
+        { key: "Fields", value: "directoryNodes" },
+        { key: "Fields", value: "versionOf" },
+        { key: "Fields", value: "titles" },
+        { key: "Fields", value: "languages" },
+        { key: "Fields", value: "labels" },
+        { key: "Fields", value: "packages" },
+        { key: "Fields", value: "created" },
+        { key: "Fields", value: "revision" }
+      );
+    }
+    return await this.request({
+      path: id,
+      params
+    });
+  }
+  /**
+   * 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 },
+        { key: "lang", value: language }
+      ],
+      transformer: (data) => transformSuggestions(data, query)
+    });
+  }
+};
+
+// ../services/src/language.ts
+var import_sdk4 = require("@c-rex/core/sdk");
+var LanguageService = class extends BaseService {
+  constructor() {
+    const sdk = new import_sdk4.CrexSDK();
+    const configs = sdk.getClientConfig();
+    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) => {
+        const countryCodeList = data.map((item) => {
+          const splittedValue = item.value.split("-");
+          const lang = splittedValue[0];
+          let country = splittedValue[0];
+          if (splittedValue.length > 1) {
+            country = splittedValue[1];
+          } else {
+            country = getCountryCodeByLang(lang);
+          }
+          return {
+            country,
+            lang,
+            value: item.value
+          };
+        });
+        return countryCodeList.sort((a, b) => {
+          return a.value.localeCompare(b.value);
+        });
+      }
+    });
+  }
+};
+
+// ../services/src/transforms/topics.ts
+var import_headers4 = require("next/headers");
+var import_logger2 = require("@c-rex/core/logger");
+var import_sdk5 = require("@c-rex/core/sdk");
+
+// src/rpc.ts
+var import_server3 = require("next/server");
+var serviceRegistry = {
+  InformationUnitsService,
+  CrexLogger: import_logger3.CrexLogger,
+  LanguageService
+};
+var POST = async (req) => {
+  try {
+    const { method, params } = await req.json();
+    const [serviceName, methodName] = method.split(".");
+    const ServiceClass = serviceRegistry[serviceName];
+    if (!ServiceClass) {
+      return import_server3.NextResponse.json({ error: `Service '${serviceName}' not found` }, { status: 404 });
+    }
+    const serviceInstance = new ServiceClass();
+    const handler = serviceInstance[methodName];
+    if (typeof handler !== "function") {
+      return import_server3.NextResponse.json({ error: `Method '${methodName}' not found on '${serviceName}'` }, { status: 404 });
+    }
+    const result = await handler.call(serviceInstance, params);
+    return import_server3.NextResponse.json({ data: result });
+  } catch (error) {
+    const logger = new import_logger3.CrexLogger();
+    logger.log({
+      level: "error",
+      message: `RPC.POST error: ${error}`
+    });
+    return import_server3.NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  POST,
+  discoverIssuerMethod,
+  getCookieFromServer,
+  getTokenMethod,
+  saveCookie
+});
+//# sourceMappingURL=index.js.map