data-solectrus 0.2.10

package/lib/jsonpath.js

@@ -0,0 +1,202 @@
+'use strict';
+
+/**
+ * Minimal JSONPath subset evaluator for typical IoT payloads.
+ * Supported examples:
+ * - $.apower
+ * - $.aenergy.by_minute[2]
+ * - $['temperature']['tC']
+ *
+ * Not supported: filters, wildcards, unions, recursive descent, functions.
+ */
+function applyJsonPath(obj, path) {
+	if (!path) return undefined;
+	let p = String(path).trim();
+	if (!p) return undefined;
+
+	// Accept both "$.x" and ".x" as a convenience.
+	if (p.startsWith('.')) {
+		p = `$${p}`;
+	}
+	if (!p.startsWith('$')) {
+		return undefined;
+	}
+
+	let cur = obj;
+	let i = 1; // skip '$'
+	const len = p.length;
+	const isDangerousKey = k => k === '__proto__' || k === 'prototype' || k === 'constructor';
+	while (i < len) {
+		const ch = p[i];
+		if (ch === '.') {
+			i++;
+			let start = i;
+			while (i < len && /[A-Za-z0-9_]/.test(p[i])) i++;
+			const key = p.slice(start, i);
+			if (!key) return undefined;
+			if (isDangerousKey(key)) return undefined;
+			if (cur === null || cur === undefined) return undefined;
+			cur = cur[key];
+			continue;
+		}
+		if (ch === '[') {
+			i++;
+			while (i < len && /\s/.test(p[i])) i++;
+			if (i >= len) return undefined;
+			const quote = p[i] === '"' || p[i] === "'" ? p[i] : null;
+			if (quote) {
+				i++;
+				let str = '';
+				while (i < len) {
+					const c = p[i];
+					if (c === '\\') {
+						if (i + 1 < len) {
+							str += p[i + 1];
+							i += 2;
+							continue;
+						}
+						return undefined;
+					}
+					if (c === quote) {
+						i++;
+						break;
+					}
+					str += c;
+					i++;
+				}
+				while (i < len && /\s/.test(p[i])) i++;
+				if (p[i] !== ']') return undefined;
+				i++;
+				if (isDangerousKey(str)) return undefined;
+				if (cur === null || cur === undefined) return undefined;
+				cur = cur[str];
+				continue;
+			}
+
+			// array index
+			let start = i;
+			while (i < len && /[0-9]/.test(p[i])) i++;
+			const numStr = p.slice(start, i);
+			while (i < len && /\s/.test(p[i])) i++;
+			if (p[i] !== ']') return undefined;
+			i++;
+			const idx = Number(numStr);
+			if (!Number.isInteger(idx)) return undefined;
+			if (!Array.isArray(cur)) return undefined;
+			cur = cur[idx];
+			continue;
+		}
+
+		// Unknown token
+		return undefined;
+	}
+	return cur;
+}
+
+function getNumericFromJsonPath(rawValue, jsonPath, opts) {
+	const options = opts || {};
+	const safeNum = typeof options.safeNum === 'function' ? options.safeNum : v => {
+		const n = Number(v);
+		return Number.isFinite(n) ? n : 0;
+	};
+	const warnOnce = typeof options.warnOnce === 'function' ? options.warnOnce : () => {};
+	const debugOnce = typeof options.debugOnce === 'function' ? options.debugOnce : () => {};
+	const warnKeyPrefix = options.warnKeyPrefix || '';
+
+	const jp = jsonPath !== undefined && jsonPath !== null ? String(jsonPath).trim() : '';
+	if (!jp) {
+		return safeNum(rawValue);
+	}
+
+	// Be forgiving: if the value is already numeric-ish, just use it.
+	// This allows mixed setups where a state sometimes is numeric and sometimes JSON-string.
+	if (typeof rawValue === 'number' || typeof rawValue === 'boolean') {
+		debugOnce(
+			`jsonpath_skipped_numeric|${warnKeyPrefix || ''}`,
+			`JSONPath '${jp}' skipped because source value is already ${typeof rawValue} (${warnKeyPrefix || 'no-prefix'})`
+		);
+		return safeNum(rawValue);
+	}
+
+	let obj = null;
+	if (rawValue && typeof rawValue === 'object') {
+		obj = rawValue;
+	} else if (typeof rawValue === 'string') {
+		const s = rawValue.trim();
+		if (!s) {
+			warnOnce(`${warnKeyPrefix}|empty`, `JSONPath configured but source value is empty (${jp})`);
+			return 0;
+		}
+		try {
+			obj = JSON.parse(s);
+		} catch (e) {
+			warnOnce(
+				`${warnKeyPrefix}|parse`,
+				`Cannot parse JSON for JSONPath ${jp}: ${e && e.message ? e.message : e}`
+			);
+			return 0;
+		}
+	} else {
+		warnOnce(`${warnKeyPrefix}|type`, `JSONPath configured but source value is not JSON (${typeof rawValue}) (${jp})`);
+		return 0;
+	}
+
+	const extracted = applyJsonPath(obj, jp);
+	if (extracted === undefined) {
+		warnOnce(`${warnKeyPrefix}|path`, `JSONPath did not match any value: ${jp}`);
+		return 0;
+	}
+	return safeNum(extracted);
+}
+
+function getValueFromJsonPath(rawValue, jsonPath, opts) {
+	const options = opts || {};
+	const warnOnce = typeof options.warnOnce === 'function' ? options.warnOnce : () => {};
+	const warnKeyPrefix = options.warnKeyPrefix || '';
+
+	const jp = jsonPath !== undefined && jsonPath !== null ? String(jsonPath).trim() : '';
+	if (!jp) {
+		return rawValue;
+	}
+
+	let obj = null;
+	if (rawValue && typeof rawValue === 'object') {
+		obj = rawValue;
+	} else if (typeof rawValue === 'string') {
+		const s = rawValue.trim();
+		if (!s) {
+			warnOnce(`${warnKeyPrefix}|empty`, `JSONPath configured but source value is empty (${jp})`);
+			return undefined;
+		}
+		try {
+			obj = JSON.parse(s);
+		} catch (e) {
+			warnOnce(
+				`${warnKeyPrefix}|parse`,
+				`Cannot parse JSON for JSONPath ${jp}: ${e && e.message ? e.message : e}`
+			);
+			return undefined;
+		}
+	} else {
+		warnOnce(`${warnKeyPrefix}|type`, `JSONPath configured but source value is not JSON (${typeof rawValue}) (${jp})`);
+		return undefined;
+	}
+
+	const extracted = applyJsonPath(obj, jp);
+	if (extracted === undefined) {
+		warnOnce(`${warnKeyPrefix}|path`, `JSONPath did not match any value: ${jp}`);
+		return undefined;
+	}
+	if (extracted === null) return null;
+	const t = typeof extracted;
+	if (t === 'string' || t === 'number' || t === 'boolean') return extracted;
+	if (extracted instanceof Date && typeof extracted.toISOString === 'function') return extracted.toISOString();
+	// Keep formulas deterministic: do not expose objects/arrays.
+	return undefined;
+}
+
+module.exports = {
+	applyJsonPath,
+	getNumericFromJsonPath,
+	getValueFromJsonPath,
+};

package/lib/services/evaluator.js

@@ -0,0 +1,266 @@
+'use strict';
+
+// Evaluates item values (source mode + formula mode) and applies output shaping.
+// Intentionally kept pure-ish: it only reads via the provided adapter.
+
+const { getItemOutputId, getItemDisplayId } = require('./itemIds');
+
+function createFormulaFunctions(adapter) {
+	return {
+		min: Math.min,
+		max: Math.max,
+		pow: Math.pow,
+		abs: Math.abs,
+		round: Math.round,
+		floor: Math.floor,
+		ceil: Math.ceil,
+		// IF(condition, valueIfTrue, valueIfFalse)
+		IF: (condition, valueIfTrue, valueIfFalse) => (condition ? valueIfTrue : valueIfFalse),
+		if: (condition, valueIfTrue, valueIfFalse) => (condition ? valueIfTrue : valueIfFalse),
+		clamp: (value, min, max) => {
+			const v = Number(value);
+			const lo = Number(min);
+			const hi = Number(max);
+			if (!Number.isFinite(v)) return 0;
+			if (Number.isFinite(lo) && v < lo) return lo;
+			if (Number.isFinite(hi) && v > hi) return hi;
+			return v;
+		},
+
+		// Read a foreign state value by id from cache/snapshot (raw, but restricted to primitives).
+		v: id => {
+			const key = String(id);
+			const val = (adapter.currentSnapshot && typeof adapter.currentSnapshot.get === 'function')
+				? adapter.currentSnapshot.get(key)
+				: adapter.cache.get(key);
+			if (val === null || val === undefined) return val;
+			const t = typeof val;
+			if (t === 'string' || t === 'number' || t === 'boolean') return val;
+			if (val instanceof Date && typeof val.toISOString === 'function') return val.toISOString();
+			adapter.debugOnce(
+				`v_non_primitive|${key}`,
+				`v("${key}") returned non-primitive (${t}); treating as empty string`
+			);
+			return '';
+		},
+
+		// Extract a primitive value from a JSON payload using the adapter's minimal JSONPath subset.
+		jp: (id, jsonPath) => {
+			const key = String(id);
+			const raw = (adapter.currentSnapshot && typeof adapter.currentSnapshot.get === 'function')
+				? adapter.currentSnapshot.get(key)
+				: adapter.cache.get(key);
+			const jp = jsonPath !== undefined && jsonPath !== null ? String(jsonPath).trim() : '';
+			if (!jp) return undefined;
+
+			let obj = null;
+			if (raw && typeof raw === 'object') {
+				obj = raw;
+			} else if (typeof raw === 'string') {
+				const s = raw.trim();
+				if (!s) return undefined;
+				try {
+					obj = JSON.parse(s);
+				} catch (e) {
+					adapter.debugOnce(
+						`jp_parse_failed|${key}|${jp}`,
+						`jp("${key}", "${jp}") cannot parse JSON: ${e && e.message ? e.message : e}`
+					);
+					return undefined;
+				}
+			} else {
+				return undefined;
+			}
+
+			const extracted = adapter.applyJsonPath(obj, jp);
+			if (extracted === undefined || extracted === null) return extracted;
+			const t = typeof extracted;
+			if (t === 'string' || t === 'number' || t === 'boolean') return extracted;
+			if (extracted instanceof Date && typeof extracted.toISOString === 'function') return extracted.toISOString();
+			return undefined;
+		},
+
+		// Read a foreign state value by id from cache (sync, safe numeric).
+		s: id => {
+			const key = String(id);
+			if (adapter.currentSnapshot && typeof adapter.currentSnapshot.get === 'function') {
+				return adapter.safeNum(adapter.currentSnapshot.get(key));
+			}
+			return adapter.safeNum(adapter.cache.get(key));
+		},
+	};
+}
+
+function isNumericOutputItem(item) {
+	const t = item && item.type ? String(item.type) : '';
+	// Only these should be forced numeric and get clamping/noNegative rules.
+	return t === '' || t === 'number';
+}
+
+function getZeroValueForItem(item) {
+	const t = item && item.type ? String(item.type) : '';
+	if (t === 'string') return '';
+	if (t === 'boolean') return false;
+	return 0;
+}
+
+async function computeItemValue(adapter, item, snapshot) {
+	const mode = item.mode || 'formula';
+	if (mode === 'source') {
+		const id = item.sourceState ? String(item.sourceState) : '';
+		const raw = snapshot ? snapshot.get(id) : adapter.cache.get(id);
+
+		// Source-mode supports both numeric (default) and non-numeric outputs.
+		// For numeric outputs we keep the existing behavior (numeric extraction + optional output clamp).
+		if (isNumericOutputItem(item)) {
+			let v = adapter.getNumericFromJsonPath(
+				raw,
+				item && item.jsonPath,
+				`item|${id}|${item && item.targetId ? item.targetId : ''}`
+			);
+			// item.noNegative is an OUTPUT rule; for source-mode numeric it's equivalent to clamping the mirrored value.
+			if (item && item.noNegative && v < 0) {
+				v = 0;
+			}
+			return v;
+		}
+
+		const hasJsonPath = item && item.jsonPath !== undefined && item.jsonPath !== null && String(item.jsonPath).trim() !== '';
+		const value = hasJsonPath
+			? adapter.getValueFromJsonPath(raw, item && item.jsonPath, `item|${id}|${item && item.targetId ? item.targetId : ''}`)
+			: raw;
+
+		// Keep output values safe and predictable: only allow primitives.
+		if (value === null || value === undefined) return value;
+		const t = typeof value;
+		if (t === 'string' || t === 'number' || t === 'boolean') return value;
+		if (value instanceof Date && typeof value.toISOString === 'function') return value.toISOString();
+		adapter.debugOnce(
+			`source_non_primitive|${id}|${item && item.targetId ? item.targetId : ''}`,
+			`Source state '${id}' returned non-primitive (${t}); treating as empty string`
+		);
+		return '';
+	}
+
+	const inputs = Array.isArray(item.inputs) ? item.inputs : [];
+	/** @type {Record<string, any>} */
+	const vars = Object.create(null);
+
+	for (const inp of inputs) {
+		if (!inp || typeof inp !== 'object') continue;
+		const keyRaw = inp.key ? String(inp.key).trim() : '';
+		const key = keyRaw.replace(/[^a-zA-Z0-9_]/g, '_');
+		if (key === '__proto__' || key === 'prototype' || key === 'constructor') {
+			const itemId = getItemDisplayId(item) || ((item && item.name) ? String(item.name) : '');
+			adapter.debugOnce(
+				`blocked_input_key|${itemId}|${key}`,
+				`Blocked dangerous input key '${keyRaw}' (sanitized to '${key}') for item '${itemId}'`
+			);
+			continue;
+		}
+		if (!key) continue;
+
+		const id = inp.sourceState ? String(inp.sourceState) : '';
+		const raw = snapshot ? snapshot.get(id) : adapter.cache.get(id);
+		let value;
+
+		const hasJsonPath = inp && inp.jsonPath !== undefined && inp.jsonPath !== null && String(inp.jsonPath).trim() !== '';
+		if (hasJsonPath) {
+			const extracted = adapter.getValueFromJsonPath(raw, inp && inp.jsonPath, `input|${id}|${key}`);
+			if (typeof extracted === 'string') {
+				const n = Number(extracted);
+				value = Number.isFinite(n) ? n : extracted;
+			} else {
+				value = extracted;
+			}
+		} else {
+			// Backwards compatible default: inputs without JSONPath are treated as numeric.
+			value = adapter.safeNum(raw);
+		}
+
+		// Clamp negative inputs BEFORE formula evaluation (only if numeric).
+		// Important: item.noNegative is an OUTPUT rule and must not affect inputs.
+		// Use per-input noNegative to clamp only those specific sources.
+		if (typeof value === 'number' && (inp && inp.noNegative) && value < 0) {
+			value = 0;
+		}
+		vars[key] = value;
+	}
+
+	const expr = item.formula ? String(item.formula).trim() : '';
+	if (!expr) return 0;
+
+	// Prefer compiled AST if available.
+	const targetId = getItemOutputId(item);
+	const compiled = targetId ? adapter.compiledItems.get(targetId) : null;
+	if (compiled && compiled.ok) {
+		if (compiled.constantValue !== undefined) {
+			return compiled.constantValue;
+		}
+		if (compiled.ast) {
+			return adapter.evalFormulaAst(compiled.ast, vars);
+		}
+		return adapter.evalFormula(expr, vars);
+	}
+	if (compiled && !compiled.ok) {
+		throw new Error(compiled.error || 'Formula compile failed');
+	}
+	return adapter.evalFormula(expr, vars);
+}
+
+function applyResultRules(adapter, item, value) {
+	let v = adapter.safeNum(value);
+
+	const toOptionalNumber = val => {
+		if (val === undefined || val === null) return NaN;
+		if (typeof val === 'string' && val.trim() === '') return NaN;
+		const n = Number(val);
+		return Number.isFinite(n) ? n : NaN;
+	};
+
+	if (item && item.noNegative && v < 0) {
+		v = 0;
+	}
+
+	if (item && item.clamp) {
+		const min = toOptionalNumber(item.min);
+		const max = toOptionalNumber(item.max);
+		if (Number.isFinite(min) && v < min) v = min;
+		if (Number.isFinite(max) && v > max) v = max;
+	}
+
+	return v;
+}
+
+function castValueForItemType(adapter, item, value) {
+	const t = item && item.type ? String(item.type) : '';
+	if (t === 'boolean') {
+		if (typeof value === 'boolean') return value;
+		if (typeof value === 'number') return Number.isFinite(value) ? value !== 0 : false;
+		if (typeof value === 'string') {
+			const s = value.trim().toLowerCase();
+			if (s === 'true' || s === 'on' || s === 'yes' || s === '1') return true;
+			if (s === 'false' || s === 'off' || s === 'no' || s === '0' || s === '') return false;
+			const n = Number(value);
+			return Number.isFinite(n) ? n !== 0 : false;
+		}
+		return false;
+	}
+	if (t === 'string') {
+		if (value === undefined || value === null) return '';
+		return String(value);
+	}
+	if (t === 'mixed') {
+		return value;
+	}
+	return adapter.safeNum(value);
+}
+
+module.exports = {
+	createFormulaFunctions,
+	isNumericOutputItem,
+	getZeroValueForItem,
+	computeItemValue,
+	applyResultRules,
+	castValueForItemType,
+};

package/lib/services/itemIds.js

@@ -0,0 +1,56 @@
+'use strict';
+
+// Helpers for computing adapter-owned ids derived from the user config.
+// Kept separate so other modules can stay free of adapter-class details.
+
+function calcTitle(item) {
+	const enabled = !!(item && item.enabled);
+	const displayId = getItemDisplayId(item);
+	const name = (item && item.name) ? String(item.name) : (displayId || 'Item');
+	return `${enabled ? '🟢 ' : '⚪ '}${name}`;
+}
+
+function getItemDisplayId(item) {
+	const group = item && item.group ? String(item.group).trim() : '';
+	const targetId = item && item.targetId ? String(item.targetId).trim() : '';
+	if (group && targetId) return `${group}.${targetId}`;
+	return targetId || group;
+}
+
+function isValidRelativeId(id) {
+	if (!id) return false;
+	const raw = String(id).trim();
+	if (!raw) return false;
+	// No absolute IDs; must be relative within this adapter
+	if (raw.includes('..') || raw.startsWith('.') || raw.endsWith('.')) return false;
+	// Keep it conservative: segments of [a-zA-Z0-9_-] separated by dots
+	return /^[A-Za-z0-9_-]+(\.[A-Za-z0-9_-]+)*$/.test(raw);
+}
+
+function getItemTargetId(item) {
+	const raw = item && item.targetId ? String(item.targetId).trim() : '';
+	if (!raw) return '';
+	return isValidRelativeId(raw) ? raw : '';
+}
+
+function getItemGroupId(item) {
+	const raw = item && item.group ? String(item.group).trim() : '';
+	if (!raw) return '';
+	return isValidRelativeId(raw) ? raw : '';
+}
+
+function getItemOutputId(item) {
+	const group = getItemGroupId(item);
+	const targetId = getItemTargetId(item);
+	if (!targetId) return '';
+	return group ? `${group}.${targetId}` : targetId;
+}
+
+module.exports = {
+	calcTitle,
+	getItemDisplayId,
+	isValidRelativeId,
+	getItemTargetId,
+	getItemGroupId,
+	getItemOutputId,
+};