data-solectrus 0.2.10

package/lib/services/stateRegistry.js

@@ -0,0 +1,462 @@
+'use strict';
+
+// Creates/extends ioBroker objects for this adapter.
+// Goal: keep state/object boilerplate out of the runtime logic.
+
+const { getItemOutputId } = require('./itemIds');
+
+function isDiagnosticsEnabled(raw, fallback = true) {
+	if (raw === undefined) return fallback;
+	if (raw === false || raw === 0 || raw === '0') return false;
+	if (typeof raw === 'string' && raw.trim().toLowerCase() === 'false') return false;
+	return true;
+}
+
+function getItemInfoBaseId(outputId) {
+	return `items.${String(outputId)}`;
+}
+
+async function ensureChannelPath(adapter, id) {
+	const raw = id ? String(id).trim() : '';
+	if (!raw) return;
+	const parts = raw.split('.').filter(Boolean);
+	if (parts.length <= 1) return;
+
+	let prefix = '';
+	for (let i = 0; i < parts.length - 1; i++) {
+		prefix = prefix ? `${prefix}.${parts[i]}` : parts[i];
+		await adapter.setObjectNotExistsAsync(prefix, {
+			type: 'channel',
+			common: { name: parts[i] },
+			native: {},
+		});
+	}
+}
+
+async function ensureOutputState(adapter, item) {
+	const id = getItemOutputId(item);
+	if (!id) return;
+
+	await ensureChannelPath(adapter, id);
+
+	const typeMap = {
+		number: 'number',
+		boolean: 'boolean',
+		string: 'string',
+		mixed: 'mixed',
+	};
+	const commonType = typeMap[item.type] || 'number';
+
+	/** @type {ioBroker.SettableStateObject} */
+	const obj = {
+		type: 'state',
+		common: {
+			name: item.name || id,
+			type: commonType,
+			role: item.role || 'value',
+			unit: item.unit || undefined,
+			read: true,
+			write: false,
+		},
+		native: {
+			mode: item.mode || 'formula',
+		},
+	};
+
+	const existing = await adapter.getObjectAsync(id);
+	if (!existing) {
+		await adapter.setObjectAsync(id, obj);
+	} else {
+		await adapter.extendObjectAsync(id, obj);
+	}
+}
+
+async function ensureItemInfoStatesForCompiled(adapter, compiled) {
+	if (!compiled || !compiled.outputId) return;
+	const base = getItemInfoBaseId(compiled.outputId);
+
+	await ensureChannelPath(adapter, `${base}.compiledOk`);
+
+	await adapter.setObjectNotExistsAsync(`${base}.compiledOk`, {
+		type: 'state',
+		common: {
+			name: 'Compiled OK',
+			type: 'boolean',
+			role: 'indicator',
+			read: true,
+			write: false,
+		},
+		native: {},
+	});
+
+	await adapter.setObjectNotExistsAsync(`${base}.compileError`, {
+		type: 'state',
+		common: {
+			name: 'Compile Error',
+			type: 'string',
+			role: 'text',
+			read: true,
+			write: false,
+		},
+		native: {},
+	});
+
+	await adapter.setObjectNotExistsAsync(`${base}.lastError`, {
+		type: 'state',
+		common: {
+			name: 'Last Error',
+			type: 'string',
+			role: 'text',
+			read: true,
+			write: false,
+		},
+		native: {},
+	});
+
+	await adapter.setObjectNotExistsAsync(`${base}.lastOkTs`, {
+		type: 'state',
+		common: {
+			name: 'Last OK Timestamp',
+			type: 'string',
+			role: 'date',
+			read: true,
+			write: false,
+		},
+		native: {},
+	});
+
+	await adapter.setObjectNotExistsAsync(`${base}.lastEvalMs`, {
+		type: 'state',
+		common: {
+			name: 'Last Evaluation Time (ms)',
+			type: 'number',
+			role: 'value',
+			read: true,
+			write: false,
+			unit: 'ms',
+		},
+		native: {},
+	});
+
+	await adapter.setObjectNotExistsAsync(`${base}.consecutiveErrors`, {
+		type: 'state',
+		common: {
+			name: 'Consecutive Errors',
+			type: 'number',
+			role: 'value',
+			read: true,
+			write: false,
+		},
+		native: {},
+	});
+}
+
+/**
+ * Cleans up old info.* states to ensure a fresh structure after updates.
+ * Preserves info.connection (managed by ioBroker core).
+ */
+async function cleanupOldInfoStates(adapter) {
+	try {
+		const objects = await adapter.getObjectViewAsync('system', 'state', {
+			startkey: `${adapter.namespace}.info.`,
+			endkey: `${adapter.namespace}.info.\u9999`,
+		});
+
+		if (objects && objects.rows) {
+			for (const row of objects.rows) {
+				const id = row.id.replace(`${adapter.namespace}.`, '');
+				// Preserve connection (ioBroker standard)
+				if (id === 'info.connection') continue;
+
+				try {
+					await adapter.delObjectAsync(id);
+				} catch (e) {
+					// Ignore delete errors (state might not exist)
+				}
+			}
+		}
+	} catch (e) {
+		adapter.log.debug(`Cleanup old info states: ${e && e.message ? e.message : e}`);
+	}
+}
+
+/**
+ * Creates info states according to Variante D:
+ * - info.* (6 core states for users)
+ * - info.diagnostics.* (evaluation stats)
+ * - info.diagnostics.timing.* (timestamp skew diagnostics)
+ */
+async function createInfoStates(adapter) {
+	// Core info states (alphabetically ordered for readability)
+	await adapter.setObjectNotExistsAsync('info.itemsActive', {
+		type: 'state',
+		common: {
+			name: 'Active items',
+			type: 'number',
+			role: 'value',
+			read: true,
+			write: false,
+		},
+		native: {},
+	});
+
+	await adapter.setObjectNotExistsAsync('info.lastError', {
+		type: 'state',
+		common: {
+			name: 'Last error',
+			type: 'string',
+			role: 'text',
+			read: true,
+			write: false,
+		},
+		native: {},
+	});
+
+	await adapter.setObjectNotExistsAsync('info.lastRun', {
+		type: 'state',
+		common: {
+			name: 'Last run',
+			type: 'string',
+			role: 'date',
+			read: true,
+			write: false,
+		},
+		native: {},
+	});
+
+	await adapter.setObjectNotExistsAsync('info.lastRunMs', {
+		type: 'state',
+		common: {
+			name: 'Last run duration',
+			type: 'number',
+			role: 'value',
+			unit: 'ms',
+			read: true,
+			write: false,
+		},
+		native: {},
+	});
+
+	await adapter.setObjectNotExistsAsync('info.status', {
+		type: 'state',
+		common: {
+			name: 'Status',
+			type: 'string',
+			role: 'text',
+			read: true,
+			write: false,
+		},
+		native: {},
+	});
+
+	// Diagnostics channel
+	await ensureChannelPath(adapter, 'info.diagnostics.evalBudgetMs');
+
+	await adapter.setObjectNotExistsAsync('info.diagnostics.evalBudgetMs', {
+		type: 'state',
+		common: {
+			name: 'Evaluation budget',
+			type: 'number',
+			role: 'value',
+			unit: 'ms',
+			read: true,
+			write: false,
+		},
+		native: {},
+	});
+
+	await adapter.setObjectNotExistsAsync('info.diagnostics.evalSkipped', {
+		type: 'state',
+		common: {
+			name: 'Skipped items (last tick)',
+			type: 'number',
+			role: 'value',
+			read: true,
+			write: false,
+		},
+		native: {},
+	});
+
+	await adapter.setObjectNotExistsAsync('info.diagnostics.itemsTotal', {
+		type: 'state',
+		common: {
+			name: 'Total configured items',
+			type: 'number',
+			role: 'value',
+			read: true,
+			write: false,
+		},
+		native: {},
+	});
+
+	// Diagnostics timing channel (alphabetically ordered)
+	await ensureChannelPath(adapter, 'info.diagnostics.timing.gapMs');
+
+	await adapter.setObjectNotExistsAsync('info.diagnostics.timing.gapActiveMs', {
+		type: 'state',
+		common: {
+			name: 'Timestamp gap (active sources)',
+			type: 'number',
+			role: 'value',
+			unit: 'ms',
+			read: true,
+			write: false,
+		},
+		native: {},
+	});
+
+	await adapter.setObjectNotExistsAsync('info.diagnostics.timing.gapActiveOk', {
+		type: 'state',
+		common: {
+			name: 'Timestamp gap (active) OK',
+			type: 'boolean',
+			role: 'indicator',
+			read: true,
+			write: false,
+		},
+		native: {},
+	});
+
+	await adapter.setObjectNotExistsAsync('info.diagnostics.timing.gapMs', {
+		type: 'state',
+		common: {
+			name: 'Timestamp gap (all sources)',
+			type: 'number',
+			role: 'value',
+			unit: 'ms',
+			read: true,
+			write: false,
+		},
+		native: {},
+	});
+
+	await adapter.setObjectNotExistsAsync('info.diagnostics.timing.gapOk', {
+		type: 'state',
+		common: {
+			name: 'Timestamp gap OK',
+			type: 'boolean',
+			role: 'indicator',
+			read: true,
+			write: false,
+		},
+		native: {},
+	});
+
+	await adapter.setObjectNotExistsAsync('info.diagnostics.timing.newestAgeMs', {
+		type: 'state',
+		common: {
+			name: 'Newest source age',
+			type: 'number',
+			role: 'value',
+			unit: 'ms',
+			read: true,
+			write: false,
+		},
+		native: {},
+	});
+
+	await adapter.setObjectNotExistsAsync('info.diagnostics.timing.newestId', {
+		type: 'state',
+		common: {
+			name: 'Newest source ID',
+			type: 'string',
+			role: 'text',
+			read: true,
+			write: false,
+		},
+		native: {},
+	});
+
+	await adapter.setObjectNotExistsAsync('info.diagnostics.timing.oldestAgeMs', {
+		type: 'state',
+		common: {
+			name: 'Oldest source age',
+			type: 'number',
+			role: 'value',
+			unit: 'ms',
+			read: true,
+			write: false,
+		},
+		native: {},
+	});
+
+	await adapter.setObjectNotExistsAsync('info.diagnostics.timing.oldestId', {
+		type: 'state',
+		common: {
+			name: 'Oldest source ID',
+			type: 'string',
+			role: 'text',
+			read: true,
+			write: false,
+		},
+		native: {},
+	});
+
+	await adapter.setObjectNotExistsAsync('info.diagnostics.timing.sources', {
+		type: 'state',
+		common: {
+			name: 'Sources with timestamps',
+			type: 'number',
+			role: 'value',
+			read: true,
+			write: false,
+		},
+		native: {},
+	});
+
+	await adapter.setObjectNotExistsAsync('info.diagnostics.timing.sourcesActive', {
+		type: 'state',
+		common: {
+			name: 'Active sources',
+			type: 'number',
+			role: 'value',
+			read: true,
+			write: false,
+		},
+		native: {},
+	});
+
+	await adapter.setObjectNotExistsAsync('info.diagnostics.timing.sourcesSleeping', {
+		type: 'state',
+		common: {
+			name: 'Sleeping sources',
+			type: 'number',
+			role: 'value',
+			read: true,
+			write: false,
+		},
+		native: {},
+	});
+
+	// Initialize state values
+	await adapter.setStateAsync('info.status', 'starting', true);
+	await adapter.setStateAsync('info.itemsActive', 0, true);
+	await adapter.setStateAsync('info.lastError', '', true);
+	await adapter.setStateAsync('info.lastRun', '', true);
+	await adapter.setStateAsync('info.lastRunMs', 0, true);
+
+	await adapter.setStateAsync('info.diagnostics.itemsTotal', 0, true);
+	await adapter.setStateAsync('info.diagnostics.evalBudgetMs', 0, true);
+	await adapter.setStateAsync('info.diagnostics.evalSkipped', 0, true);
+
+	await adapter.setStateAsync('info.diagnostics.timing.gapMs', 0, true);
+	await adapter.setStateAsync('info.diagnostics.timing.gapOk', true, true);
+	await adapter.setStateAsync('info.diagnostics.timing.gapActiveMs', 0, true);
+	await adapter.setStateAsync('info.diagnostics.timing.gapActiveOk', true, true);
+	await adapter.setStateAsync('info.diagnostics.timing.sources', 0, true);
+	await adapter.setStateAsync('info.diagnostics.timing.sourcesActive', 0, true);
+	await adapter.setStateAsync('info.diagnostics.timing.sourcesSleeping', 0, true);
+	await adapter.setStateAsync('info.diagnostics.timing.oldestId', '', true);
+	await adapter.setStateAsync('info.diagnostics.timing.oldestAgeMs', 0, true);
+	await adapter.setStateAsync('info.diagnostics.timing.newestId', '', true);
+	await adapter.setStateAsync('info.diagnostics.timing.newestAgeMs', 0, true);
+}
+
+module.exports = {
+	getItemInfoBaseId,
+	ensureChannelPath,
+	ensureOutputState,
+	ensureItemInfoStatesForCompiled,
+	cleanupOldInfoStates,
+	createInfoStates,
+};

package/lib/services/subscriptions.js

@@ -0,0 +1,83 @@
+'use strict';
+
+// Computes which foreign ids should be subscribed/snapshotted based on enabled items.
+
+const { getItemOutputId } = require('./itemIds');
+const { collectSourceStatesFromItem } = require('./sourceDiscovery');
+
+function getMaxTotalSourceIds(adapter) {
+	const raw = Number(adapter.MAX_TOTAL_SOURCE_IDS);
+	if (!Number.isFinite(raw) || raw <= 0) return 5000;
+	return Math.min(50000, Math.round(raw));
+}
+
+function getDesiredSourceIdsForItems(adapter, items) {
+	const enabledItems = Array.isArray(items)
+		? items.filter(it => it && typeof it === 'object' && it.enabled)
+		: [];
+
+	const desired = new Set();
+	for (const item of enabledItems) {
+		const out = getItemOutputId(item);
+		const compiled = out ? adapter.compiledItems.get(out) : null;
+		if (compiled && compiled.sourceIds) {
+			for (const id of compiled.sourceIds) {
+				if (id) desired.add(String(id));
+			}
+		} else {
+			for (const id of collectSourceStatesFromItem(adapter, item)) {
+				if (id) desired.add(String(id));
+			}
+		}
+	}
+
+	const cap = getMaxTotalSourceIds(adapter);
+	if (desired.size > cap) {
+		const kept = new Set();
+		let n = 0;
+		for (const id of desired) {
+			kept.add(id);
+			n++;
+			if (n >= cap) break;
+		}
+		adapter.warnOnce(
+			`source_ids_cap|${cap}`,
+			`Too many source state ids (${desired.size}); limiting subscriptions/snapshot to first ${cap}. Please reduce configured items/inputs.`
+		);
+		return kept;
+	}
+	return desired;
+}
+
+function syncSubscriptions(adapter, desiredIds) {
+	const desired = desiredIds instanceof Set ? desiredIds : new Set();
+
+	// Unsubscribe stale ids
+	for (const id of Array.from(adapter.subscribedIds)) {
+		if (!desired.has(id)) {
+			try {
+				adapter.unsubscribeForeignStates(id);
+			} catch (e) {
+				adapter.log.debug(`Cannot unsubscribe ${id}: ${e && e.message ? e.message : e}`);
+			} finally {
+				adapter.subscribedIds.delete(id);
+			}
+		}
+	}
+
+	// Subscribe missing ids
+	for (const id of desired) {
+		if (adapter.subscribedIds.has(id)) continue;
+		try {
+			adapter.subscribeForeignStates(id);
+			adapter.subscribedIds.add(id);
+		} catch (e) {
+			adapter.log.warn(`Cannot subscribe ${id}: ${e && e.message ? e.message : e}`);
+		}
+	}
+}
+
+module.exports = {
+	getDesiredSourceIdsForItems,
+	syncSubscriptions,
+};