@gisatcz/ptr-be-core 0.0.1-dev.7 → 0.0.1-dev.9

package/dist/index.node.cjs

@@ -1,7 +1,10 @@
 'use strict';
 
+var luxon = require('luxon');
 var pino = require('pino');
 var pretty = require('pino-pretty');
+var crypto = require('crypto');
+var _ = require('lodash');
 
 /**
  * Check if the value in included in enum posibilities.
@@ -98,6 +101,206 @@ const flattenObject = (obj, prefix = '') => {
     }, {});
 };
 
+/**
+ * Extract message from exception error (try-catch)
+ * @param error error from catch block as any
+ * @returns
+ */
+const messageFromError = (error) => error["message"];
+/**
+ * We miss a API parameter needed to process action
+ */
+class InvalidRequestError extends Error {
+    constructor(message) {
+        super(`Invalid Request: ${message}`);
+    }
+}
+/**
+ * Where client has general authorization issue
+ */
+class AuthorizationError extends Error {
+    constructor() {
+        super(`Authorization has failed.`);
+    }
+}
+
+/**
+ * Return epoch timestamp
+ * @param regime Set if you want milisecond format or second format
+ * @returns
+ */
+const nowTimestamp = (regime = "milisecond") => {
+    const timestamp = luxon.DateTime.now().toMillis();
+    return regime === "second" ? Math.round((timestamp / 1000)) : timestamp;
+};
+/**
+ * Convert epoch time value into ISO format
+ * @param epochValue Epoch value of the timestamp
+ * @returns ISO format of the date
+ */
+const epochToIsoFormat = (epochValue) => luxon.DateTime.fromMillis(epochValue).toISO();
+/**
+ * Return epoch timestamp
+ * @param regime Set if you want milisecond format or second format
+ * @returns
+ */
+const nowTimestampIso = () => {
+    const timestamp = luxon.DateTime.now().toISO();
+    return timestamp;
+};
+/**
+ * Check if input date is valid for ISO format
+ * @param dateToCheck
+ * @returns
+ */
+const hasIsoFormat = (dateToCheck) => {
+    try {
+        const toDate = new Date(Date.parse(dateToCheck));
+        const isoCheck = toDate.toISOString().includes(dateToCheck);
+        return isoCheck;
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Convert date in ISO formtat to milisecond timestamp
+ * @param isoDate Date in ISO 8601 format
+ * @returns Timestamp representing the date in miliseconds
+ */
+const isoDateToTimestamp = (isoDate) => luxon.DateTime.fromISO(isoDate).toMillis();
+/**
+ * Format ISO 8601 interval to from-to values
+ * @param interval Defined inteval in ISO format (from/to) of the UTC
+ * @returns Tuple - from timestamp and to timestamp
+ */
+const isoIntervalToTimestamps = (interval) => {
+    // Split the interval into two parts
+    const intervals = interval.split("/");
+    // interval as a single year has just one part
+    if (intervals.length == 1) {
+        const newIso = `${interval}-01-01/${interval}-12-31`;
+        return isoIntervalToTimestamps(newIso);
+    }
+    // interval with two parts or less than one
+    else if (intervals.length > 2 || intervals.length < 1)
+        throw new InvalidRequestError("Interval can have only two parameters");
+    // valid interval with two parts
+    else {
+        if (!intervals.every(interval => hasIsoFormat(interval)))
+            throw new InvalidRequestError("Parameter utcIntervalIso is not ISO 8601 time interval (date01/date02) or year");
+        const [int1, int2] = intervals.map(intervalIso => {
+            const cleared = intervalIso.replace(" ", "");
+            return isoDateToTimestamp(cleared);
+        });
+        return [int1, int2];
+    }
+};
+
+// TODO: Cover by tests
+// TODO: mode to ptr-be-core as general CSV methods
+/**
+ * Parses a single line of CSV-formatted strings into an array of trimmed string values.
+ *
+ * @param csvStingsLine - A string representing a single line of comma-separated values.
+ * @returns An array of strings, each representing a trimmed value from the CSV line.
+ */
+const csvParseStrings = (csvStingsLine) => {
+    return csvStingsLine.split(",").map((value) => value.trim());
+};
+/**
+ * Parses a comma-separated string of numbers into an array of numbers.
+ *
+ * @param csvNumbersLine - A string containing numbers separated by commas (e.g., "1, 2, 3.5").
+ * @returns An array of numbers parsed from the input string.
+ */
+const csvParseNumbers = (csvNumbersLine) => {
+    return csvNumbersLine.split(",").map((value) => parseFloat(value.trim()));
+};
+
+/**
+ * Finds the first node in the provided list that contains the specified label.
+ *
+ * Searches the given array of FullPantherEntity objects and returns the first entity
+ * whose `labels` array includes the provided label.
+ *
+ * @param nodes - Array of FullPantherEntity objects to search through.
+ * @param label - Label to match; may be a UsedDatasourceLabels or UsedNodeLabels.
+ * @returns The first FullPantherEntity whose `labels` includes `label`, or `undefined`
+ *          if no such entity is found.
+ *
+ * @remarks
+ * - The search stops at the first match (uses `Array.prototype.find`).
+ * - Label comparison is exact (uses `Array.prototype.includes`), so it is case-sensitive
+ *   and requires the same string instance/value.
+ *
+ * @example
+ * const result = findNodeByLabel(nodes, 'datasource-main');
+ * if (result) {
+ *   // found a node that has the 'datasource-main' label
+ * }
+ */
+const findNodeByLabel = (nodes, label) => {
+    return nodes.find(n => n.labels.includes(label));
+};
+/**
+ * Filters an array of FullPantherEntity objects, returning only those that contain the specified label.
+ *
+ * The function performs a shallow, non-mutating filter: it returns a new array and does not modify the input.
+ * Matching is done using Array.prototype.includes on each entity's `labels` array (strict equality).
+ *
+ * @param nodes - The array of entities to filter.
+ * @param label - The label to match; can be a UsedDatasourceLabels or UsedNodeLabels value.
+ * @returns A new array containing only the entities whose `labels` array includes the provided label.
+ *
+ * @remarks
+ * Time complexity is O(n * m) where n is the number of entities and m is the average number of labels per entity.
+ *
+ * @example
+ * ```ts
+ * const matched = filterNodeByLabel(entities, 'MY_LABEL');
+ * ```
+ */
+const filterNodeByLabel = (nodes, label) => {
+    return nodes.filter(n => n.labels.includes(label));
+};
+/**
+ * Finds the first edge in the provided array whose label strictly equals the given label.
+ *
+ * @param edges - Array of GraphEdge objects to search.
+ * @param label - The UsedEdgeLabels value to match against each edge's `label` property.
+ * @returns The first matching GraphEdge if found; otherwise `undefined`.
+ *
+ * @example
+ * const edge = findEdgeByLabel(edges, 'dependency');
+ * if (edge) {
+ *   // handle found edge
+ * }
+ */
+const findEdgeByLabel = (edges, label) => {
+    return edges.find(e => e.label === label);
+};
+/**
+ * Filters a list of GraphEdge objects by a specific edge label.
+ *
+ * Returns a new array containing only those edges whose `label` property
+ * strictly equals the provided `label` argument. The original `edges`
+ * array is not mutated.
+ *
+ * @param edges - Array of GraphEdge objects to filter.
+ * @param label - The label to match; comparison is performed using strict (`===`) equality.
+ * @returns A new array of GraphEdge objects whose `label` matches the provided label. Returns an empty array if no edges match.
+ *
+ * @remarks
+ * Time complexity: O(n), where n is the number of edges.
+ *
+ * @example
+ * // const result = filterEdgeByLabel(edges, 'CONNECTS');
+ */
+const filterEdgeByLabel = (edges, label) => {
+    return edges.filter(e => e.label === label);
+};
+
 /**
  * What types of graph nodes we use in metadata model
  */
@@ -156,29 +359,6 @@ exports.UsedTimeseriesSteps = void 0;
     UsedTimeseriesSteps["Day"] = "day";
 })(exports.UsedTimeseriesSteps || (exports.UsedTimeseriesSteps = {}));
 
-/**
- * Extract message from exception error (try-catch)
- * @param error error from catch block as any
- * @returns
- */
-const messageFromError = (error) => error["message"];
-/**
- * We miss a API parameter needed to process action
- */
-class InvalidRequestError extends Error {
-    constructor(message) {
-        super(`Invalid Request: ${message}`);
-    }
-}
-/**
- * Where client has general authorization issue
- */
-class AuthorizationError extends Error {
-    constructor() {
-        super(`Authorization has failed.`);
-    }
-}
-
 // logger.ts
 const DEFAULT_LOG_OPTIONS = {
     label: 'App'
@@ -206,17 +386,553 @@ class AppLogger {
     }
 }
 
+/**
+ * Validates the provided labels to ensure they are an array of strings and that each label
+ * is a valid value within the specified enums (`UsedNodeLabels` or `UsedDatasourceLabels`).
+ *
+ * @param labels - The input to validate, expected to be an array of strings.
+ * @throws {InvalidRequestError} If `labels` is not an array.
+ * @throws {InvalidRequestError} If any label in the array is not a valid value in the combined enums.
+ */
+const validateNodeLabels = (labels) => {
+    if (labels === undefined || labels === null) {
+        throw new InvalidRequestError("Graph node labels are required.");
+    }
+    if (!_.isArray(labels))
+        throw new InvalidRequestError(`Graph node labels must be an array of strings.`);
+    if (labels.length === 0)
+        throw new InvalidRequestError("Graph node labels array must contain at least one label.");
+    for (const label of labels) {
+        if (!isInEnum(label, exports.UsedNodeLabels) && !isInEnum(label, exports.UsedDatasourceLabels))
+            throw new InvalidRequestError(`Label ${label} is not supported. Value must be one of: ${enumCombineValuesToString([exports.UsedNodeLabels, exports.UsedDatasourceLabels])}`);
+    }
+};
+/**
+ * Validate a graph edge label.
+ *
+ * The value is first checked for presence (not `undefined`/`null`), then for type (`string`).
+ * The string is normalised using `toLocaleLowerCase()` and validated against the `UsedEdgeLabels` enum.
+ *
+ * @param label - The value to validate; expected to be a string representing an edge label.
+ *
+ * @throws {InvalidRequestError} If `label` is `undefined` or `null`.
+ * @throws {InvalidRequestError} If `label` is not a `string`.
+ * @throws {InvalidRequestError} If the normalised label is not one of the supported values in `UsedEdgeLabels`.
+ *
+ * @example
+ * validateEdgeLabel('CONNECTS'); // succeeds if 'connects' exists in UsedEdgeLabels
+ *
+ * @remarks
+ * Membership is determined via `isInEnum` and error messages include the allowed values (via `enumCombineValuesToString`).
+ */
+const validateEdgeLabel = (label) => {
+    if (label === undefined || label === null) {
+        throw new InvalidRequestError("Graph edge label is required.");
+    }
+    if (typeof label !== "string") {
+        throw new InvalidRequestError(`Graph edge label must be a string.`);
+    }
+    const normalisedLabel = label.toLocaleLowerCase();
+    if (!isInEnum(normalisedLabel, exports.UsedEdgeLabels)) {
+        throw new InvalidRequestError(`Graph edge label '${normalisedLabel}' is not supported. Value must be one of: ${enumCombineValuesToString([exports.UsedEdgeLabels])}`);
+    }
+};
+
+/**
+ * Extract and parse basic entitry from request body
+ * This parse function is used in other parsers, becuase basic entity is part of other models
+ * @param bodyRaw Body from http request
+ * @param key Optional - key value for existing recods in database
+ * @returns Parsed entity - all unwanted parameters are gone
+ */
+const parseBasicNodeFromBody = (bodyRaw) => {
+    const { labels, nameInternal, nameDisplay, description, key } = bodyRaw;
+    validateNodeLabels(labels);
+    const basicGraphResult = {
+        lastUpdatedAt: nowTimestamp(),
+        key: key ?? crypto.randomUUID(),
+        nameInternal: nameInternal ?? "",
+        nameDisplay: nameDisplay ?? "",
+        description: description ?? "",
+        labels: labels
+    };
+    return basicGraphResult;
+};
+/**
+ * Parse node of type area tree level
+ * @param levelBody Content from request
+ * @returns Parsed area tree level
+ */
+const paseHasLevels = (levelBody) => {
+    const { level } = levelBody;
+    const result = {
+        level
+    };
+    return result;
+};
+/**
+ * Parse body to period entity
+ * @param bodyRaw Request body content - can be anything
+ * @returns Parsed entity - all unwanted parameters are gone
+ */
+const parseWithInterval = (bodyRaw) => {
+    const { intervalISO, } = bodyRaw;
+    if (!intervalISO)
+        throw new InvalidRequestError("Period must have UTC interval in ISO format");
+    const [from, to] = isoIntervalToTimestamps(intervalISO);
+    const intervalResult = {
+        validIntervalIso: intervalISO,
+        validFrom: from,
+        validTo: to
+    };
+    return intervalResult;
+};
+const parseWithConfiguration = (bodyRaw, required = false) => {
+    const { configuration } = bodyRaw;
+    if (!configuration && required)
+        throw new InvalidRequestError("Configuration is required");
+    if (!configuration)
+        return;
+    return { configuration: typeof configuration === 'string' ? configuration : JSON.stringify(configuration) };
+};
+/**
+ * Parse body to place entity
+ * @param bodyRaw Request body content - can be anything
+ * @returns
+ */
+const parseHasGeometry = (bodyRaw) => {
+    const { bbox, geometry, } = bodyRaw;
+    /**
+     * Convert bbox from CSV string to array of 4 coordinates
+     * @returns Parsed bounding box from CSV string
+     */
+    const bboxFromCSV = () => {
+        const bboxFromCSV = csvParseNumbers(bbox);
+        if (bboxFromCSV.length !== 4)
+            throw new InvalidRequestError("bbox must be an array of 4 numbers");
+        return bboxFromCSV;
+    };
+    const geometryResult = {
+        bbox: bbox ? bboxFromCSV() : [],
+        geometry: geometry ?? ""
+    };
+    return geometryResult;
+};
+/**
+ * Parses the input object and extracts the `url` property.
+ * If the `url` property is not present or is undefined, it returns `null` for `url`.
+ *
+ * @param bodyRaw - The raw input object that may contain a `url` property.
+ * @returns An object with a single `url` property, which is either the extracted value or `null`.
+ */
+const parseHasUrl = (bodyRaw, isRequired = true) => {
+    const { url } = bodyRaw;
+    if (isRequired && !url)
+        throw new InvalidRequestError("Url is required for the node");
+    if (!url)
+        return;
+    return { url };
+};
+/**
+ * Parses the `specificName` property from the provided object and returns it wrapped in a `HasSpecificName` type.
+ *
+ * @param bodyRaw - The raw input object potentially containing the `specificName` property.
+ * @param isRequired - If `true`, throws an `InvalidRequestError` when `specificName` is missing. Defaults to `false`.
+ * @returns An object with the `specificName` property if present, or `undefined` if not required and missing.
+ * @throws {InvalidRequestError} If `isRequired` is `true` and `specificName` is not provided.
+ */
+const parseHasSpecificName = (bodyRaw, isRequired = false) => {
+    const { specificName } = bodyRaw;
+    if (isRequired && !specificName)
+        throw new InvalidRequestError("Property specificName is required for the node");
+    if (!specificName)
+        return;
+    return { specificName };
+};
+/**
+ * Parses the `color` property from the provided `bodyRaw` object and returns it
+ * wrapped in an object if it exists. If the `isRequired` flag is set to `true`
+ * and the `color` property is missing, an error is thrown.
+ *
+ * @param bodyRaw - The raw input object containing the `color` property.
+ * @param isRequired - A boolean indicating whether the `color` property is required.
+ *                      Defaults to `false`.
+ * @returns An object containing the `color` property if it exists, or `undefined` if not required.
+ * @throws {InvalidRequestError} If `isRequired` is `true` and the `color` property is missing.
+ */
+const parseWithColor = (bodyRaw, isRequired = false) => {
+    const { color } = bodyRaw;
+    if (isRequired && !color)
+        throw new InvalidRequestError("Property color is required for the node");
+    if (!color)
+        return;
+    return { color };
+};
+/**
+ * Parses the provided raw body object to extract unit and valueType properties.
+ * Ensures that the required properties are present if `isRequired` is set to true.
+ *
+ * @param bodyRaw - The raw input object containing the properties to parse.
+ * @param isRequired - A boolean indicating whether the `unit` and `valueType` properties are mandatory.
+ *                      Defaults to `false`.
+ * @returns An object containing the `unit` and `valueType` properties, or `null` if they are not provided.
+ * @throws {InvalidRequestError} If `isRequired` is true and either `unit` or `valueType` is missing.
+ */
+const parseWithUnits = (bodyRaw, isRequired = false) => {
+    const { unit, valueType } = bodyRaw;
+    if (isRequired && (!unit || !valueType))
+        throw new InvalidRequestError("Properties unit and valueType are required for the node");
+    return { unit: unit ?? null, valueType: valueType ?? null };
+};
+/**
+ * Parse and validate the `documentId` property from a raw request body.
+ *
+ * Extracts `documentId` from `bodyRaw` and returns it as an object matching
+ * HasDocumentId, wrapped in the Unsure type. If `documentId` is missing or
+ * falsy, the function throws an InvalidRequestError.
+ *
+ * @param bodyRaw - The raw request body (e.g. parsed JSON) expected to contain `documentId`.
+ * @returns Unsure<HasDocumentId> — an object with the `documentId` property.
+ * @throws {InvalidRequestError} Thrown when `documentId` is not present on `bodyRaw`.
+ */
+const parseHasDocumentId = (bodyRaw) => {
+    const { documentId } = bodyRaw;
+    if (!documentId)
+        throw new InvalidRequestError("Property documentId is required for the node");
+    return { documentId };
+};
+/**
+ * Parse timeseries information from a raw request body.
+ *
+ * Delegates interval parsing to `parseWithInterval(bodyRaw)` and then
+ * attaches the `step` value from the provided `bodyRaw` to the resulting
+ * timeseries object. The function does not mutate the input object.
+ *
+ * @param bodyRaw - Raw request payload (unknown/loose shape). Expected to
+ *                  contain whatever fields `parseWithInterval` requires and
+ *                  optionally a `step` property.
+ * @returns A `HasTimeseries` object composed of the interval-related fields
+ *          returned by `parseWithInterval` plus the `step` property from
+ *          `bodyRaw` (which may be `undefined` if not present).
+ * @throws Rethrows any errors produced by `parseWithInterval` when the input
+ *         body is invalid for interval parsing.
+ */
+const parseWithTimeseries = (bodyRaw) => {
+    const timeseriesIntervals = parseWithInterval(bodyRaw);
+    const { step } = bodyRaw;
+    if (!step)
+        throw new InvalidRequestError("Property step is required for timeseries datasource");
+    return { ...timeseriesIntervals, step };
+};
+/**
+ * Parses the `bands`, `bandNames`, and `bandPeriods` properties from the provided raw input object.
+ *
+ * - If `required` is `true`, throws an `InvalidRequestError` if any of the properties are missing.
+ * - Converts CSV strings to arrays:
+ *   - `bands` is parsed as an array of numbers.
+ *   - `bandNames` and `bandPeriods` are parsed as arrays of trimmed strings.
+ * - Returns an object containing any of the parsed properties that were present in the input.
+ *
+ * @param bodyRaw - The raw input object potentially containing `bands`, `bandNames`, and `bandPeriods` as CSV strings.
+ * @param required - If `true`, all three properties are required and an error is thrown if any are missing. Defaults to `false`.
+ * @returns An object with the parsed properties, or `undefined` if none are present.
+ * @throws {InvalidRequestError} If `required` is `true` and any property is missing.
+ */
+const parseHasBands = (bodyRaw, required = false) => {
+    const { bands, bandNames, bandPeriods } = bodyRaw;
+    let result;
+    if (required && (!bands || !bandNames || !bandPeriods))
+        throw new InvalidRequestError("Bands, bandNames and bandPeriods are required for the node");
+    if (bands) {
+        result = result ?? {};
+        Object.assign(result, { bands: csvParseNumbers(bands) });
+    }
+    if (bandNames) {
+        result = result ?? {};
+        Object.assign(result, { bandNames: csvParseStrings(bandNames) });
+    }
+    if (bandPeriods) {
+        result = result ?? {};
+        Object.assign(result, { bandPeriods: csvParseStrings(bandPeriods) });
+    }
+    return result;
+};
+/**
+ * Parse single graph node from body entity
+ * @param bodyNodeEntity Entity from request body
+ * @returns Parsed object for specific node
+ */
+const parseSinglePantherNode = (bodyNodeEntity) => {
+    // Parse basic node properties first
+    let node = parseBasicNodeFromBody(bodyNodeEntity);
+    // Parse additional properties for specific node types
+    // single for loop is used to avoid multiple labels array iterations
+    for (const label of node.labels) {
+        // If node is a Period, add interval information
+        if (label === exports.UsedNodeLabels.Period)
+            node = { ...node, ...parseWithInterval(bodyNodeEntity) };
+        // If node is a Place, add geographic information
+        if (label === exports.UsedNodeLabels.Place)
+            node = { ...node, ...parseHasGeometry(bodyNodeEntity) };
+        // If node is a Datasource or Application, add configuration when available
+        if (label === exports.UsedNodeLabels.Datasource || label === exports.UsedNodeLabels.Application) {
+            const parsedConfiguration = parseWithConfiguration(bodyNodeEntity, false);
+            node = parsedConfiguration ? { ...node, ...parsedConfiguration } : node;
+        }
+        // If node is a online Datasource, add URL information
+        const datasourcesWithUrl = [
+            exports.UsedDatasourceLabels.COG,
+            exports.UsedDatasourceLabels.WMS,
+            exports.UsedDatasourceLabels.MVT,
+            exports.UsedDatasourceLabels.WFS,
+            exports.UsedDatasourceLabels.WMTS,
+            exports.UsedDatasourceLabels.Geojson
+        ];
+        // If node is a Datasource with URL, add URL information
+        if (datasourcesWithUrl.includes(label)) {
+            const parsedUrl = parseHasUrl(bodyNodeEntity, true);
+            node = parsedUrl ? { ...node, ...parsedUrl } : node;
+        }
+        // If node is a Datasource with bands, add bands information
+        const datasourcesWithPossibleBands = [
+            exports.UsedDatasourceLabels.COG,
+        ];
+        // If node is a Datasource can have bands, add them
+        if (datasourcesWithPossibleBands.includes(label)) {
+            const parsedBands = parseHasBands(bodyNodeEntity, false);
+            node = parsedBands ? { ...node, ...parsedBands } : node;
+        }
+        // If node is a Style, add specific name information
+        if (label === exports.UsedNodeLabels.Style || label === exports.UsedDatasourceLabels.MapStyle) {
+            const parsedSpecificName = parseHasSpecificName(bodyNodeEntity, true);
+            node = parsedSpecificName ? { ...node, ...parsedSpecificName } : node;
+        }
+        // If node is a Datasource with timeseries, add timeseries information
+        if (label === exports.UsedDatasourceLabels.Timeseries) {
+            const parsedTimeseries = parseWithTimeseries(bodyNodeEntity);
+            node = { ...node, ...parsedTimeseries };
+        }
+        // If node is a Datasource with document ID, add document ID information
+        const datasourcesWithDocumentId = [
+            exports.UsedDatasourceLabels.PostGIS,
+            exports.UsedDatasourceLabels.Timeseries
+        ];
+        if (datasourcesWithDocumentId.includes(label)) {
+            const parsedDocumentId = parseHasDocumentId(bodyNodeEntity);
+            node = { ...node, ...parsedDocumentId };
+        }
+        // If node is an AreaTreeLevel, add level information
+        if (label === exports.UsedNodeLabels.AreaTreeLevel)
+            node = { ...node, ...paseHasLevels(bodyNodeEntity) };
+        // If node is an Attribute, add color information and units
+        if (label === exports.UsedNodeLabels.Attribute) {
+            const parsedColor = parseWithColor(bodyNodeEntity, false);
+            const parsedUnit = parseWithUnits(bodyNodeEntity, false);
+            // Add parsed unit if available
+            node = parsedUnit ? {
+                ...node,
+                ...parsedUnit
+            } : node;
+            // Add parsed color if available
+            node = parsedColor ? {
+                ...node,
+                ...parsedColor
+            } : node;
+        }
+    }
+    return node;
+};
+/**
+ * Parse array of graph nodes from request body
+ * @param body Array of graph nodes inside http request body
+ * @returns Array of parsed graph nodes in correct form
+ */
+const parseParsePantherNodes = (body) => {
+    const nodeArray = body;
+    if (!_.isArray(nodeArray))
+        throw new InvalidRequestError("Request: Grah nodes must be an array");
+    return nodeArray.map(PantherEntity => parseSinglePantherNode(PantherEntity));
+};
+// TODO: cover by better testing
+
+/**
+ * Parses a node object from the Arrows JSON format and converts it into a `PantherEntity`.
+ *
+ * Validates that the node's labels are arrays of supported enum values, and constructs
+ * a `PantherEntity` object with the appropriate properties. Throws an `InvalidRequestError`
+ * if the labels are not valid.
+ *
+ * @param node - The node object from the Arrows JSON to parse.
+ * @returns A `PantherEntity` object representing the parsed node.
+ * @throws {InvalidRequestError} If the node's labels are not an array of supported values.
+ */
+const parseNodeFromArrows = (node) => {
+    const { labels, properties, id, caption } = node;
+    validateNodeLabels(labels);
+    const basicGraphResult = parseSinglePantherNode({
+        labels: labels,
+        key: properties.key ?? id ?? crypto.randomUUID(),
+        nameDisplay: caption ?? properties.nameDisplay ?? "",
+        ...properties
+    });
+    return basicGraphResult;
+};
+/**
+ * Parses an edge object from the Arrows format and converts it into a `GraphEdge`.
+ *
+ * @param edge - The edge object to parse, containing details about the graph edge.
+ * @returns A `GraphEdge` object containing the parsed edge nodes, label, and properties.
+ *
+ * @throws {InvalidRequestError} If the edge does not have a type (`label`).
+ * @throws {InvalidRequestError} If the edge type (`label`) is not supported.
+ * @throws {InvalidRequestError} If the edge does not have properties.
+ * @throws {InvalidRequestError} If the edge does not have `fromId` or `toId`.
+ * @throws {InvalidRequestError} If the `fromId` and `toId` are the same.
+ */
+const parseEdgeFromArrows = (edge) => {
+    const { fromId: from, toId: to, type, properties } = edge;
+    // Determine the label, defaulting to "RelatedTo" if the type is invalid or not provided
+    const label = (typeof type === "string" && type.trim().length > 0)
+        ? type.trim()
+        : exports.UsedEdgeLabels.RelatedTo;
+    // validate the edge properties
+    if (!isInEnum(label, exports.UsedEdgeLabels))
+        throw new InvalidRequestError(`Graph edge type '${label}' is not supported`);
+    // edge must have a properties
+    if (!properties)
+        throw new InvalidRequestError(`Graph edge must have properties`);
+    // edge must have fromId and toId
+    if (!from || !to)
+        throw new InvalidRequestError(`Graph edge must have fromId and toId`);
+    if (from === to)
+        throw new InvalidRequestError(`Cannot connect two same keys in graph relation (${from} leads to ${to})`);
+    // prepare relation tuple
+    const result = [from, to];
+    // construct the parsed edge object
+    const parsedEdge = {
+        edgeNodes: result,
+        label,
+        properties
+    };
+    // return the parsed edge
+    return parsedEdge;
+};
+/**
+ * Parses a JSON object representing nodes and relationships (edges) from the Arrows JSON.
+ *
+ * @param body - The input JSON object to parse. Expected to contain `nodes` and `relationships` arrays.
+ * @returns An object containing parsed `nodes` and `edges` arrays.
+ * @throws {InvalidRequestError} If the input is not a valid object, or if required properties are missing or not arrays.
+ */
+const parseArrowsJson = (body) => {
+    // Check if the body is a valid object
+    if (typeof body !== "object" || body === null)
+        throw new InvalidRequestError("Invalid JSON format");
+    // Check if the body contains the required properties
+    if (!("nodes" in body) || !("relationships" in body))
+        throw new InvalidRequestError("Invalid JSON format: Missing nodes or relationships");
+    // Check if nodes and relationships are arrays
+    if (!_.isArray(body.nodes) || !_.isArray(body.relationships))
+        throw new InvalidRequestError("Invalid JSON format: nodes and relationships must be arrays");
+    // Extract nodes and relationships from the body
+    const { nodes: rawNodes, relationships: rawEdges } = body;
+    // Define default values for nodes and edges
+    const nodes = rawNodes ?? [];
+    const edges = rawEdges ?? [];
+    // Parse nodes and edges using the defined functions
+    const parsedNodes = nodes.map((node) => parseNodeFromArrows(node));
+    const parsedEdges = edges.map((edge) => parseEdgeFromArrows(edge));
+    return {
+        nodes: parsedNodes,
+        edges: parsedEdges
+    };
+};
+
+const parseRichEdges = (body) => {
+    const parseSingleEdge = (edge) => {
+        const { label, fromKey, toKey, properties } = edge;
+        if (!label || typeof label !== "string")
+            throw new InvalidRequestError("Every graph edge must have string label");
+        if (!isInEnum(label, exports.UsedEdgeLabels))
+            throw new InvalidRequestError(`Graph edge label is not allowed (${label}). Must be one of: ${enumValuesToString(exports.UsedEdgeLabels)}`);
+        if (!fromKey || typeof fromKey !== "string")
+            throw new InvalidRequestError("Every graph edge must have string fromKey");
+        if (!toKey || typeof toKey !== "string")
+            throw new InvalidRequestError("Every graph edge must have string toKey");
+        if (fromKey === toKey)
+            throw new InvalidRequestError(`Cannot connect two same keys in graph edge (${fromKey})`);
+        const parsedEdge = {
+            label: label,
+            edgeNodes: [fromKey, toKey],
+            properties: properties || {}
+        };
+        return parsedEdge;
+    };
+    const edgesRaw = body;
+    if (!_.isArray(edgesRaw))
+        throw new InvalidRequestError("Graph edges must be an array of edges");
+    if (edgesRaw.length === 0)
+        throw new InvalidRequestError("Graph edges array must not be empty");
+    const parsedEdges = edgesRaw.map(edge => parseSingleEdge(edge));
+    return parsedEdges;
+};
+/**
+ * Parse body to graph relation
+ * @param body Body from request
+ * @returns Graph relation
+ */
+const parseEqualEdges = (body) => {
+    const relations = body;
+    /**
+     * Check single edge relation and parse it
+     * @param edgeRelation
+     * @returns Parsed edge relation
+     */
+    const parseSingleEdgeRelation = (edgeRelation) => {
+        if (!_.isArray(edgeRelation))
+            throw new InvalidRequestError("Every graph relation must be two element string tuple [string, string]");
+        if (edgeRelation.length !== 2)
+            throw new InvalidRequestError("Every graph relation must be two element string tuple [string, string]");
+        if (edgeRelation[0] === edgeRelation[1])
+            throw new InvalidRequestError(`Cannot connect two same keys in graph relation (${edgeRelation[0]})`);
+        return edgeRelation;
+    };
+    if (!_.isArray(relations))
+        throw new InvalidRequestError("Graph edges must be an array of tuples");
+    const validatedGraphEdges = relations.map(edge => parseSingleEdgeRelation(edge));
+    return validatedGraphEdges;
+};
+
 exports.AppLogger = AppLogger;
 exports.AuthorizationError = AuthorizationError;
 exports.InvalidRequestError = InvalidRequestError;
+exports.csvParseNumbers = csvParseNumbers;
+exports.csvParseStrings = csvParseStrings;
 exports.enumCombineValuesToString = enumCombineValuesToString;
 exports.enumValuesToArray = enumValuesToArray;
 exports.enumValuesToString = enumValuesToString;
+exports.epochToIsoFormat = epochToIsoFormat;
+exports.filterEdgeByLabel = filterEdgeByLabel;
+exports.filterNodeByLabel = filterNodeByLabel;
+exports.findEdgeByLabel = findEdgeByLabel;
+exports.findNodeByLabel = findNodeByLabel;
 exports.flattenObject = flattenObject;
+exports.hasIsoFormat = hasIsoFormat;
 exports.isInEnum = isInEnum;
+exports.isoDateToTimestamp = isoDateToTimestamp;
+exports.isoIntervalToTimestamps = isoIntervalToTimestamps;
 exports.messageFromError = messageFromError;
 exports.notEmptyString = notEmptyString;
+exports.nowTimestamp = nowTimestamp;
+exports.nowTimestampIso = nowTimestampIso;
+exports.parseArrowsJson = parseArrowsJson;
+exports.parseEqualEdges = parseEqualEdges;
+exports.parseParsePantherNodes = parseParsePantherNodes;
+exports.parseRichEdges = parseRichEdges;
+exports.parseSinglePantherNode = parseSinglePantherNode;
 exports.randomNumberBetween = randomNumberBetween;
 exports.removeDuplicitiesFromArray = removeDuplicitiesFromArray;
 exports.sortStringArray = sortStringArray;
+exports.validateEdgeLabel = validateEdgeLabel;
+exports.validateNodeLabels = validateNodeLabels;
 //# sourceMappingURL=index.node.cjs.map