@evenicanpm/admin-integrate 2.3.1 → 2.4.1

package/src/components/templatesV2/utils/parseTemplateValuesFromConfig.ts

@@ -1,311 +0,0 @@
-export interface Mapping {
-	fieldName: string;
-	jsonPath: string;
-	jsonValuePath: string;
-	format: string;
-	inputTypeCode?: string;
-}
-
-export function parseWithMappings(
-	input: { json: Record<string, unknown> },
-	mappings: Mapping[],
-): Record<string, unknown> {
-	const result: Record<string, unknown> = {};
-
-	for (const mapping of mappings) {
-		const { fieldName, jsonPath, format } = mapping;
-
-		const pathValue = resolvePath(input.json, jsonPath);
-		if (pathValue === undefined || pathValue === null) {
-			result[fieldName] = mapping.inputTypeCode === "input-table" ? [] : null;
-			continue;
-		}
-
-		const parsed = parseValueFromFormat(format, fieldName, pathValue);
-		const isEmptyForInputTable =
-			mapping.inputTypeCode === "input-table" &&
-			(parsed === "" ||
-				(typeof parsed === "object" &&
-					parsed !== null &&
-					!Array.isArray(parsed) &&
-					Object.keys(parsed).length === 0));
-		result[fieldName] = isEmptyForInputTable ? [] : parsed;
-	}
-
-	return result;
-}
-
-function stripPathPrefix(path: string): string {
-	if (path.startsWith("$.")) return path.slice(2);
-	if (path.startsWith("$")) return path.slice(1);
-	return path;
-}
-
-function walkSegment(current: unknown, segment: string | number): unknown {
-	if (typeof segment === "number") {
-		if (!Array.isArray(current)) return undefined;
-		return current[segment];
-	}
-	if (typeof current !== "object" || Array.isArray(current)) return undefined;
-	return (current as Record<string, unknown>)[segment];
-}
-
-/** Walks an object/array using a simple JSONPath expression (dot + bracket notation). */
-function resolvePath(obj: unknown, path: string): unknown {
-	if (path === "$") return obj;
-
-	const stripped = stripPathPrefix(path);
-	if (!stripped) return obj;
-
-	let current: unknown = obj;
-	for (const segment of parsePathSegments(stripped)) {
-		if (current === null || current === undefined) return undefined;
-		current = walkSegment(current, segment);
-	}
-	return current;
-}
-
-/** Splits a stripped JSONPath string into typed segments, e.g. "Processes[0].ProcessTasks[1].Name" */
-function parsePathSegments(path: string): (string | number)[] {
-	const segments: (string | number)[] = [];
-	const regex = /([^.[\]]+)|\[(\d+)\]/g;
-	let match: RegExpExecArray | null;
-	while ((match = regex.exec(path)) !== null) {
-		if (match[1] !== undefined) segments.push(match[1]);
-		else if (match[2] !== undefined)
-			segments.push(Number.parseInt(match[2], 10));
-	}
-	return segments;
-}
-
-/**
- * Applies the format string to the extracted value.
- * - If format is exactly `{0}` or `{fieldName}`, the raw value is returned as-is.
- * - Otherwise `{0}` / `{fieldName}` tokens are replaced with the stringified value.
- *   If the result is valid JSON it is parsed back to an object.
- */
-function toValueString(value: unknown): string {
-	if (value == null) return "";
-	if (typeof value === "string") return value;
-	if (
-		typeof value === "number" ||
-		typeof value === "boolean" ||
-		typeof value === "bigint"
-	)
-		return String(value);
-	if (typeof value === "object") return JSON.stringify(value);
-	return "";
-}
-
-function escapeRegex(str: string): string {
-	return str.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
-}
-
-function findPlaceholderInArray(
-	arr: unknown[],
-	placeholder: string,
-): string[] | null {
-	for (let i = 0; i < arr.length; i++) {
-		const path = findPlaceholderPath(arr[i], placeholder);
-		if (path !== null) return [String(i), ...path];
-	}
-	return null;
-}
-
-function findPlaceholderInObject(
-	obj: Record<string, unknown>,
-	placeholder: string,
-): string[] | null {
-	for (const [key, val] of Object.entries(obj)) {
-		const path = findPlaceholderPath(val, placeholder);
-		if (path !== null) return [key, ...path];
-	}
-	return null;
-}
-
-/**
- * Recursively searches an object/array for the first occurrence of `placeholder`
- * as a string value, returning the key path to it, or `null` if not found.
- */
-function findPlaceholderPath(
-	obj: unknown,
-	placeholder: string,
-): string[] | null {
-	if (typeof obj === "string") return obj === placeholder ? [] : null;
-	if (Array.isArray(obj)) return findPlaceholderInArray(obj, placeholder);
-	if (typeof obj === "object" && obj !== null) {
-		return findPlaceholderInObject(obj as Record<string, unknown>, placeholder);
-	}
-	return null;
-}
-
-function navigatePath(obj: unknown, path: string[]): unknown {
-	let current: unknown = obj;
-	for (const key of path) {
-		if (current === null || current === undefined) return undefined;
-		if (Array.isArray(current)) {
-			current = current[Number(key)];
-		} else if (typeof current === "object") {
-			current = (current as Record<string, unknown>)[key];
-		} else {
-			return undefined;
-		}
-	}
-	return current;
-}
-
-/**
- * Like findPlaceholderPath but matches any string leaf that CONTAINS the placeholder
- * as a substring rather than being exactly equal to it.
- */
-function findContainingInArray(
-	arr: unknown[],
-	placeholder: string,
-): string[] | null {
-	for (let i = 0; i < arr.length; i++) {
-		const path = findContainingPath(arr[i], placeholder);
-		if (path !== null) return [String(i), ...path];
-	}
-	return null;
-}
-
-function findContainingInObject(
-	obj: Record<string, unknown>,
-	placeholder: string,
-): string[] | null {
-	for (const [key, val] of Object.entries(obj)) {
-		const path = findContainingPath(val, placeholder);
-		if (path !== null) return [key, ...path];
-	}
-	return null;
-}
-
-function findContainingPath(
-	obj: unknown,
-	placeholder: string,
-): string[] | null {
-	if (typeof obj === "string") return obj.includes(placeholder) ? [] : null;
-	if (Array.isArray(obj)) return findContainingInArray(obj, placeholder);
-	if (typeof obj === "object" && obj !== null)
-		return findContainingInObject(obj as Record<string, unknown>, placeholder);
-	return null;
-}
-
-/**
- * Reverse of `applyFormat`: given a format string containing `{0}` and a value
- * that was produced by that format, extracts and returns the original `{0}` value.
- *
- * For JSON formats (e.g. `{ "ConnectionName": "{0}" }`): parses both the format and
- * the value as JSON, locates the key path of `{0}` in the format structure, then
- * extracts the value at that same path from the actual value. This correctly handles
- * values with extra keys not present in the format template.
- *
- * When the placeholder is embedded within a format leaf string
- * (e.g. `{ "Sql": "exec {0}" }`), navigates to that leaf in the actual value
- * and applies regex capture within that field.
- *
- * For non-JSON formats (e.g. `"{0}_entity"`): falls back to regex capture.
- *
- * Returns `null` when no match is found.
- */
-function extractViaJsonFormat(
-	format: string,
-	placeholder0: string,
-	placeholderField: string,
-	formattedValue: unknown,
-): unknown {
-	let parsedFormat: unknown;
-	try {
-		parsedFormat = JSON.parse(format);
-	} catch {
-		return undefined;
-	}
-
-	let parsedValue: unknown = formattedValue;
-	if (typeof formattedValue === "string") {
-		try {
-			parsedValue = JSON.parse(formattedValue);
-		} catch {
-			/* use as-is */
-		}
-	}
-
-	// Exact match: the format leaf IS the placeholder
-	const exactPath =
-		findPlaceholderPath(parsedFormat, placeholder0) ??
-		findPlaceholderPath(parsedFormat, placeholderField);
-	if (exactPath !== null) {
-		return navigatePath(parsedValue, exactPath);
-	}
-
-	// Embedded match: the placeholder appears inside a format leaf string
-	const containingPath =
-		findContainingPath(parsedFormat, placeholder0) ??
-		findContainingPath(parsedFormat, placeholderField);
-	if (containingPath === null) return undefined;
-
-	const formatLeaf = navigatePath(parsedFormat, containingPath);
-	if (typeof formatLeaf !== "string") return undefined;
-
-	return extractViaRegex(
-		formatLeaf,
-		placeholder0,
-		placeholderField,
-		navigatePath(parsedValue, containingPath),
-	);
-}
-
-function extractViaRegex(
-	format: string,
-	placeholder0: string,
-	placeholderField: string,
-	formattedValue: unknown,
-): unknown {
-	const segments = format.includes(placeholder0)
-		? format.split(placeholder0)
-		: format.split(placeholderField);
-
-	if (segments.length === 1) return null;
-
-	const captureGroup = String.raw`([\s\S]*?)`;
-	const regexSource = segments.map(escapeRegex).join(captureGroup);
-	const match = new RegExp(`^${regexSource}$`).exec(
-		toValueString(formattedValue).trim(),
-	);
-	if (!match) return null;
-
-	const captured = match[1];
-	try {
-		return JSON.parse(captured);
-	} catch {
-		return captured;
-	}
-}
-
-export function parseValueFromFormat(
-	format: string,
-	fieldName: string,
-	formattedValue: unknown,
-): unknown {
-	if (format === "{0}" || format === `{${fieldName}}`) {
-		return formattedValue;
-	}
-
-	const placeholder0 = "{0}";
-	const placeholderField = `{${fieldName}}`;
-
-	const jsonResult = extractViaJsonFormat(
-		format,
-		placeholder0,
-		placeholderField,
-		formattedValue,
-	);
-	if (jsonResult !== undefined) return jsonResult;
-
-	return extractViaRegex(
-		format,
-		placeholder0,
-		placeholderField,
-		formattedValue,
-	);
-}