@fastybird/smart-panel-backend 1.0.0-beta.3 → 1.1.0-alpha.0

package/dist/plugins/devices-homey/services/homey-synchronizer.service.js

@@ -0,0 +1,628 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HomeySynchronizerService = void 0;
+const common_1 = require("@nestjs/common");
+const event_emitter_1 = require("@nestjs/event-emitter");
+const logger_1 = require("../../../common/logger");
+const devices_constants_1 = require("../../../modules/devices/devices.constants");
+const channels_properties_service_1 = require("../../../modules/devices/services/channels.properties.service");
+const device_connectivity_service_1 = require("../../../modules/devices/services/device-connectivity.service");
+const devices_service_1 = require("../../../modules/devices/services/devices.service");
+const devices_homey_constants_1 = require("../devices-homey.constants");
+const devices_homey_entity_1 = require("../entities/devices-homey.entity");
+const device_support_1 = require("../mappings/device-support");
+const mapping_loader_service_1 = require("../mappings/mapping-loader.service");
+const mapping_transformer_service_1 = require("../mappings/mapping-transformer.service");
+const homey_event_model_1 = require("../models/homey-event.model");
+const inventory_model_1 = require("../models/inventory.model");
+const homey_failure_log_limiter_1 = require("./homey-failure-log-limiter");
+let HomeySynchronizerService = class HomeySynchronizerService {
+    constructor(devicesService, channelsPropertiesService, deviceConnectivityService, mappingLoader, transformer) {
+        this.devicesService = devicesService;
+        this.channelsPropertiesService = channelsPropertiesService;
+        this.deviceConnectivityService = deviceConnectivityService;
+        this.mappingLoader = mappingLoader;
+        this.transformer = transformer;
+        this.logger = (0, logger_1.createExtensionLogger)(devices_homey_constants_1.DEVICES_HOMEY_PLUGIN_NAME, 'Synchronizer');
+        this.failureLogLimiter = new homey_failure_log_limiter_1.HomeyFailureLogLimiter();
+        this.adoptedDevices = new Map();
+        this.propertiesByDeviceCapability = new Map();
+        this.lastAppliedOrder = new Map();
+        this.lastAppliedValues = new Map();
+        this.lastPersistedValueTimestamp = new Map();
+        this.lastObservedOrder = new Map();
+        this.lastAppliedDeviceOrder = new Map();
+        this.lastObservedDeviceOrder = new Map();
+        this.arrivalOrder = 0;
+        this.indexDirty = true;
+        this.indexRefresh = null;
+        this.indexGeneration = 0;
+    }
+    invalidateFromEntity() {
+        this.invalidateIndex();
+    }
+    recordPersistedPropertyValue(property) {
+        if (property.type !== devices_homey_constants_1.DEVICES_HOMEY_TYPE) {
+            return;
+        }
+        const timestamp = this.parseTimestamp(property.value?.lastUpdated ?? null);
+        if (timestamp === null) {
+            return;
+        }
+        const previousTimestamp = this.lastPersistedValueTimestamp.get(property.id);
+        this.lastPersistedValueTimestamp.set(property.id, previousTimestamp === undefined ? timestamp : Math.max(timestamp, previousTimestamp));
+    }
+    invalidateIndex() {
+        this.indexDirty = true;
+        this.indexGeneration += 1;
+    }
+    async refreshIndex() {
+        this.invalidateIndex();
+        await this.ensureIndex();
+    }
+    async synchronizeSnapshot(devices, readbackEvents = []) {
+        await this.refreshIndex();
+        const upstreamDevices = new Map(devices.map((device) => [device.id, device]));
+        const result = this.emptyResult();
+        const connectionStateApplied = new Map();
+        const acceptedCapabilityValues = [];
+        for (const [homeyDeviceId, adopted] of this.adoptedDevices) {
+            const upstream = upstreamDevices.get(homeyDeviceId);
+            if (upstream === undefined) {
+                connectionStateApplied.set(homeyDeviceId, await this.setConnectionState(adopted.id, devices_constants_1.ConnectionState.LOST, result));
+                continue;
+            }
+            connectionStateApplied.set(homeyDeviceId, await this.synchronizeDevice(upstream, result, acceptedCapabilityValues));
+        }
+        const acceptedEvents = await this.commitReadbackOrder(readbackEvents, upstreamDevices, connectionStateApplied, result);
+        return { ...result, acceptedEvents, acceptedCapabilityValues };
+    }
+    async synchronizeDevices(devices, missingDeviceIds = [], readbackEvents = []) {
+        await this.ensureIndex();
+        const result = this.emptyResult();
+        const connectionStateApplied = new Map();
+        const acceptedCapabilityValues = [];
+        for (const device of devices) {
+            connectionStateApplied.set(device.id, await this.synchronizeDevice(device, result, acceptedCapabilityValues));
+        }
+        for (const homeyDeviceId of missingDeviceIds) {
+            const adopted = this.adoptedDevices.get(homeyDeviceId);
+            if (adopted !== undefined) {
+                connectionStateApplied.set(homeyDeviceId, await this.setConnectionState(adopted.id, devices_constants_1.ConnectionState.LOST, result));
+            }
+        }
+        const acceptedEvents = await this.commitReadbackOrder(readbackEvents, new Map(devices.map((device) => [device.id, device])), connectionStateApplied, result);
+        return { ...result, acceptedEvents, acceptedCapabilityValues };
+    }
+    async synchronizeEvents(events, currentDevices) {
+        await this.ensureIndex();
+        const result = this.emptyResult();
+        const acceptedEvents = [];
+        for (const event of this.filterEvents(events)) {
+            if (!this.isValidEvent(event)) {
+                result.ignored += 1;
+                continue;
+            }
+            switch (event.type) {
+                case homey_event_model_1.HomeyEventType.CAPABILITY_VALUE_CHANGED:
+                    {
+                        const currentCapability = currentDevices
+                            .get(event.deviceId)
+                            ?.capabilities.find((capability) => capability.id === event.capabilityId);
+                        if (currentCapability === undefined ||
+                            !currentCapability.readable ||
+                            currentCapability.available === false) {
+                            result.ignored += 1;
+                            break;
+                        }
+                        const applied = await this.synchronizeCapabilityValue(event.deviceId, event.capabilityId, event.value, event.lastUpdatedAt ?? event.occurredAt, event.sequence, result);
+                        if (applied) {
+                            acceptedEvents.push(event);
+                        }
+                    }
+                    break;
+                case homey_event_model_1.HomeyEventType.DEVICE_AVAILABILITY_CHANGED: {
+                    if (!currentDevices.has(event.deviceId)) {
+                        result.ignored += 1;
+                        break;
+                    }
+                    const context = this.prepareDeviceEvent(event.deviceId, event.sequence, event.occurredAt, result);
+                    if (context === null) {
+                        break;
+                    }
+                    const applied = await this.setConnectionState(context.adopted.id, event.available ? devices_constants_1.ConnectionState.CONNECTED : devices_constants_1.ConnectionState.DISCONNECTED, result);
+                    this.recordDeviceOrder(event.deviceId, context.order, applied);
+                    break;
+                }
+                case homey_event_model_1.HomeyEventType.DEVICE_ADDED:
+                case homey_event_model_1.HomeyEventType.DEVICE_UPDATED: {
+                    const context = this.prepareDeviceEvent(event.deviceId, event.sequence, event.occurredAt, result);
+                    if (context === null) {
+                        break;
+                    }
+                    const current = currentDevices.get(event.deviceId);
+                    let applied;
+                    if (current === undefined) {
+                        applied = await this.setConnectionState(context.adopted.id, devices_constants_1.ConnectionState.LOST, result);
+                    }
+                    else {
+                        applied = await this.synchronizeDevice(current, result);
+                    }
+                    this.recordDeviceOrder(event.deviceId, context.order, applied);
+                    break;
+                }
+                case homey_event_model_1.HomeyEventType.DEVICE_REMOVED: {
+                    const context = this.prepareDeviceEvent(event.deviceId, event.sequence, event.occurredAt, result);
+                    if (context === null) {
+                        break;
+                    }
+                    const applied = await this.setConnectionState(context.adopted.id, devices_constants_1.ConnectionState.LOST, result);
+                    this.recordDeviceOrder(event.deviceId, context.order, applied);
+                    break;
+                }
+                case homey_event_model_1.HomeyEventType.ZONE_ADDED:
+                case homey_event_model_1.HomeyEventType.ZONE_UPDATED:
+                case homey_event_model_1.HomeyEventType.ZONE_REMOVED:
+                    result.ignored += 1;
+                    break;
+            }
+        }
+        return { ...result, acceptedEvents };
+    }
+    filterEvents(events) {
+        return this.coalesceEvents(events).filter((event) => {
+            if (!this.isDeviceEvent(event)) {
+                return true;
+            }
+            const previousOrder = this.lastObservedDeviceOrder.get(event.deviceId);
+            return (previousOrder === undefined ||
+                this.compareOrders(this.createOrder(event.sequence, event.occurredAt), previousOrder) >= 0);
+        });
+    }
+    async hasReadableCapabilityBinding(homeyDeviceId, capabilityId) {
+        await this.ensureIndex();
+        return (this.propertiesByDeviceCapability.get(homeyDeviceId)?.get(capabilityId)?.length ?? 0) > 0;
+    }
+    async getOperationalDiagnostics(devices) {
+        await this.ensureIndex();
+        const upstreamIds = new Set(devices.map((device) => device.id));
+        const adoptedDevices = [...this.adoptedDevices.values()].map((device) => ({
+            homeyDeviceId: device.identifier,
+            panelDeviceId: device.id,
+        }));
+        return {
+            adopted: adoptedDevices.length,
+            adoptedDevices,
+            missing: adoptedDevices.filter((device) => !upstreamIds.has(device.homeyDeviceId)).length,
+            unsupported: devices.filter((device) => (0, device_support_1.resolveHomeyDeviceSupport)(this.mappingLoader, device).state !== inventory_model_1.HomeyDeviceSupportState.SUPPORTED).length,
+            unavailable: devices.filter((device) => !device.available).length,
+        };
+    }
+    reset() {
+        this.adoptedDevices.clear();
+        this.propertiesByDeviceCapability.clear();
+        this.lastAppliedOrder.clear();
+        this.lastAppliedValues.clear();
+        this.lastObservedOrder.clear();
+        this.lastAppliedDeviceOrder.clear();
+        this.lastObservedDeviceOrder.clear();
+        this.arrivalOrder = 0;
+        this.indexDirty = true;
+        this.indexGeneration += 1;
+    }
+    async ensureIndex() {
+        if (!this.indexDirty) {
+            return;
+        }
+        if (this.indexRefresh !== null) {
+            await this.indexRefresh;
+            if (this.indexDirty) {
+                await this.ensureIndex();
+            }
+            return;
+        }
+        this.indexRefresh = this.rebuildIndex();
+        try {
+            await this.indexRefresh;
+        }
+        finally {
+            this.indexRefresh = null;
+        }
+        if (this.indexDirty) {
+            await this.ensureIndex();
+        }
+    }
+    async rebuildIndex() {
+        const generation = this.indexGeneration;
+        const mappings = new Map(this.mappingLoader.getPropertyMappings().map((mapping) => [mapping.name, mapping]));
+        const devices = await this.devicesService.findAll(devices_homey_constants_1.DEVICES_HOMEY_TYPE);
+        const adoptedDevices = new Map();
+        const propertiesByDeviceCapability = new Map();
+        const persistedValueTimestamps = new Map();
+        for (const device of devices) {
+            if (device.identifier === null || !device.enabled) {
+                continue;
+            }
+            adoptedDevices.set(device.identifier, device);
+            const capabilities = new Map();
+            for (const channel of device.channels ?? []) {
+                for (const candidate of channel.properties ?? []) {
+                    const property = candidate;
+                    if (candidate.type !== devices_homey_constants_1.DEVICES_HOMEY_TYPE ||
+                        typeof property.homeyCapabilityId !== 'string' ||
+                        typeof property.homeyMappingName !== 'string') {
+                        continue;
+                    }
+                    const mapping = mappings.get(property.homeyMappingName);
+                    if (mapping === undefined || mapping.property.direction === 'write_only') {
+                        continue;
+                    }
+                    const loadedTimestamp = this.parseTimestamp(property.value?.lastUpdated ?? null);
+                    const currentTimestamp = this.lastPersistedValueTimestamp.get(property.id);
+                    const persistedTimestamp = loadedTimestamp === null
+                        ? currentTimestamp
+                        : Math.max(loadedTimestamp, currentTimestamp ?? loadedTimestamp);
+                    if (persistedTimestamp !== undefined) {
+                        persistedValueTimestamps.set(property.id, persistedTimestamp);
+                    }
+                    const bindings = capabilities.get(property.homeyCapabilityId) ?? [];
+                    bindings.push({ panelDeviceId: device.id, property, mapping });
+                    capabilities.set(property.homeyCapabilityId, bindings);
+                }
+            }
+            propertiesByDeviceCapability.set(device.identifier, capabilities);
+        }
+        this.adoptedDevices = adoptedDevices;
+        this.propertiesByDeviceCapability = propertiesByDeviceCapability;
+        this.lastPersistedValueTimestamp = persistedValueTimestamps;
+        this.indexDirty = this.indexGeneration !== generation;
+    }
+    async synchronizeDevice(device, result, acceptedCapabilityValues) {
+        const adopted = this.adoptedDevices.get(device.id);
+        if (adopted === undefined) {
+            result.ignored += 1;
+            return false;
+        }
+        const connectionStateApplied = await this.setConnectionState(adopted.id, device.available ? devices_constants_1.ConnectionState.CONNECTED : devices_constants_1.ConnectionState.DISCONNECTED, result);
+        for (const capability of device.capabilities) {
+            if (!capability.readable || capability.available === false) {
+                result.ignored += 1;
+                continue;
+            }
+            if (await this.synchronizeCapability(device.id, capability, result)) {
+                acceptedCapabilityValues?.push({
+                    deviceId: device.id,
+                    capabilityId: capability.id,
+                    value: capability.value,
+                });
+            }
+        }
+        return connectionStateApplied;
+    }
+    async synchronizeCapability(homeyDeviceId, capability, result) {
+        return this.synchronizeCapabilityValue(homeyDeviceId, capability.id, capability.value, capability.lastUpdatedAt, null, result);
+    }
+    async synchronizeCapabilityValue(homeyDeviceId, capabilityId, value, updatedAt, sequence, result) {
+        const bindings = this.propertiesByDeviceCapability.get(homeyDeviceId)?.get(capabilityId);
+        if (bindings === undefined || bindings.length === 0 || !this.isCapabilityValue(value)) {
+            result.ignored += 1;
+            return false;
+        }
+        const order = this.createOrder(sequence, updatedAt);
+        const receivedTimestamp = Date.now();
+        let allBindingsApplied = true;
+        for (const binding of bindings) {
+            const previousObservedOrder = this.lastObservedOrder.get(binding.property.id);
+            const previousOrder = this.lastAppliedOrder.get(binding.property.id);
+            const observedComparison = previousObservedOrder === undefined ? null : this.compareOrders(order, previousObservedOrder);
+            const appliedComparison = previousOrder === undefined ? null : this.compareOrders(order, previousOrder);
+            if (observedComparison !== null && observedComparison < 0) {
+                result.ignored += 1;
+                allBindingsApplied = false;
+                continue;
+            }
+            if (appliedComparison !== null && appliedComparison <= 0) {
+                result.ignored += 1;
+                allBindingsApplied =
+                    appliedComparison === 0 &&
+                        this.lastAppliedValues.has(binding.property.id) &&
+                        Object.is(this.lastAppliedValues.get(binding.property.id), value) &&
+                        allBindingsApplied;
+                continue;
+            }
+            const observedOrder = this.preserveSequenceWatermark(order, previousObservedOrder);
+            this.lastObservedOrder.set(binding.property.id, observedOrder);
+            try {
+                const transformed = this.transformer.read(binding.mapping, value);
+                const updateDto = {
+                    type: devices_homey_constants_1.DEVICES_HOMEY_TYPE,
+                    value: transformed,
+                };
+                let valueTimestamp;
+                await this.channelsPropertiesService.update(binding.property.id, updateDto, {
+                    resolveValueTimestamp: () => {
+                        valueTimestamp = this.createValueTimestamp(binding.property.id, receivedTimestamp);
+                        return valueTimestamp;
+                    },
+                });
+                if (valueTimestamp === undefined) {
+                    throw new Error('Homey value timestamp was not resolved before persistence');
+                }
+                this.lastAppliedOrder.set(binding.property.id, this.preserveSequenceWatermark(observedOrder, previousOrder));
+                this.lastAppliedValues.set(binding.property.id, value);
+                this.lastPersistedValueTimestamp.set(binding.property.id, valueTimestamp.getTime());
+                result.updated += 1;
+            }
+            catch {
+                result.failed += 1;
+                allBindingsApplied = false;
+                const decision = this.failureLogLimiter.consume('capability-update');
+                if (decision.log) {
+                    this.logger.warn('Ignored a Homey capability update that could not be mapped or persisted', {
+                        suppressed: decision.suppressed,
+                    });
+                }
+            }
+        }
+        return allBindingsApplied;
+    }
+    async commitReadbackOrder(events, currentDevices, connectionStateApplied, result) {
+        const acceptedEvents = [];
+        for (const event of this.filterEvents(events)) {
+            if (!this.isValidEvent(event)) {
+                result.ignored += 1;
+                continue;
+            }
+            if (event.type === homey_event_model_1.HomeyEventType.CAPABILITY_VALUE_CHANGED) {
+                const capability = currentDevices
+                    .get(event.deviceId)
+                    ?.capabilities.find((candidate) => candidate.id === event.capabilityId);
+                if (capability === undefined || !capability.readable || capability.available === false) {
+                    result.ignored += 1;
+                    continue;
+                }
+                const applied = await this.synchronizeCapabilityValue(event.deviceId, event.capabilityId, capability.value, null, event.sequence, result);
+                if (applied) {
+                    acceptedEvents.push({ ...event, value: capability.value });
+                }
+                continue;
+            }
+            if (!this.isDeviceEvent(event)) {
+                continue;
+            }
+            if (event.type === homey_event_model_1.HomeyEventType.DEVICE_ADDED || event.type === homey_event_model_1.HomeyEventType.DEVICE_UPDATED) {
+                const current = currentDevices.get(event.deviceId);
+                if (current !== undefined) {
+                    for (const capability of current.capabilities) {
+                        if (!capability.readable || capability.available === false) {
+                            continue;
+                        }
+                        await this.synchronizeCapabilityValue(event.deviceId, capability.id, capability.value, event.sequence === null ? event.occurredAt : null, event.sequence, result);
+                    }
+                }
+            }
+            const context = this.prepareDeviceEvent(event.deviceId, event.sequence, event.occurredAt, result);
+            if (context !== null) {
+                this.recordDeviceOrder(event.deviceId, context.order, connectionStateApplied.get(event.deviceId) === true);
+            }
+        }
+        return acceptedEvents;
+    }
+    async setConnectionState(panelDeviceId, state, result) {
+        try {
+            const applied = await this.deviceConnectivityService.trySetConnectionState(panelDeviceId, { state });
+            if (applied) {
+                result.updated += 1;
+                return true;
+            }
+        }
+        catch {
+        }
+        result.failed += 1;
+        const decision = this.failureLogLimiter.consume('connection-state-update');
+        if (decision.log) {
+            this.logger.warn('Could not update an adopted Homey device connection state', {
+                suppressed: decision.suppressed,
+            });
+        }
+        return false;
+    }
+    coalesceEvents(events) {
+        const selectedCapabilityIndexes = new Map();
+        const selectedDeviceIndexes = new Map();
+        for (let index = 0; index < events.length; index += 1) {
+            const event = events[index];
+            if (event.type === homey_event_model_1.HomeyEventType.CAPABILITY_VALUE_CHANGED) {
+                const key = `${event.deviceId}\u0000${event.capabilityId}`;
+                const selectedIndex = selectedCapabilityIndexes.get(key);
+                if (selectedIndex === undefined || this.isLaterEvent(event, events[selectedIndex])) {
+                    selectedCapabilityIndexes.set(key, index);
+                }
+            }
+            else if (this.isDeviceEvent(event)) {
+                const selected = selectedDeviceIndexes.get(event.deviceId);
+                const isRefresh = event.type === homey_event_model_1.HomeyEventType.DEVICE_ADDED || event.type === homey_event_model_1.HomeyEventType.DEVICE_UPDATED;
+                const latest = selected === undefined || this.isLaterEvent(event, events[selected.latest]) ? index : selected.latest;
+                const latestRefresh = !isRefresh
+                    ? (selected?.latestRefresh ?? null)
+                    : selected?.latestRefresh === null || selected?.latestRefresh === undefined
+                        ? index
+                        : this.isLaterEvent(event, events[selected.latestRefresh])
+                            ? index
+                            : selected.latestRefresh;
+                selectedDeviceIndexes.set(event.deviceId, { latest, latestRefresh });
+            }
+        }
+        return events.filter((event, index) => {
+            if (event.type === homey_event_model_1.HomeyEventType.CAPABILITY_VALUE_CHANGED) {
+                return selectedCapabilityIndexes.get(`${event.deviceId}\u0000${event.capabilityId}`) === index;
+            }
+            if (!this.isDeviceEvent(event)) {
+                return true;
+            }
+            const selected = selectedDeviceIndexes.get(event.deviceId);
+            if (selected === undefined || selected.latest === index) {
+                return true;
+            }
+            return (selected.latestRefresh === index && events[selected.latest].type === homey_event_model_1.HomeyEventType.DEVICE_AVAILABILITY_CHANGED);
+        });
+    }
+    preserveSequenceWatermark(order, previousOrder) {
+        if (order.sequence !== null || typeof previousOrder?.sequence !== 'number') {
+            return order;
+        }
+        return { ...order, sequence: previousOrder.sequence };
+    }
+    isLaterEvent(candidate, current) {
+        const sequenceComparison = this.compareSequences(candidate.sequence, current.sequence);
+        if (sequenceComparison !== null) {
+            return sequenceComparison > 0;
+        }
+        const candidateTimestamp = this.eventTimestamp(candidate);
+        const currentTimestamp = this.eventTimestamp(current);
+        if (candidateTimestamp !== null && currentTimestamp !== null && candidateTimestamp !== currentTimestamp) {
+            return candidateTimestamp > currentTimestamp;
+        }
+        return true;
+    }
+    eventTimestamp(event) {
+        return this.parseTimestamp(event.type === homey_event_model_1.HomeyEventType.CAPABILITY_VALUE_CHANGED
+            ? (event.lastUpdatedAt ?? event.occurredAt)
+            : event.occurredAt);
+    }
+    isNewerOrder(candidate, current) {
+        return this.compareOrders(candidate, current) > 0;
+    }
+    compareOrders(candidate, current) {
+        const sequenceComparison = this.compareSequences(candidate.sequence, current.sequence);
+        if (sequenceComparison !== null) {
+            return sequenceComparison;
+        }
+        if (candidate.timestamp !== null && current.timestamp !== null) {
+            return Math.sign(candidate.timestamp - current.timestamp);
+        }
+        return Math.sign(candidate.arrival - current.arrival);
+    }
+    createOrder(sequence, updatedAt) {
+        return {
+            sequence,
+            timestamp: this.parseTimestamp(updatedAt),
+            arrival: ++this.arrivalOrder,
+        };
+    }
+    createValueTimestamp(propertyId, receivedTimestamp) {
+        const previousTimestamp = this.lastPersistedValueTimestamp.get(propertyId);
+        const effectiveTimestamp = previousTimestamp === undefined ? receivedTimestamp : Math.max(receivedTimestamp, previousTimestamp + 1);
+        return new Date(effectiveTimestamp);
+    }
+    prepareDeviceEvent(homeyDeviceId, sequence, occurredAt, result) {
+        const adopted = this.adoptedDevices.get(homeyDeviceId);
+        if (adopted === undefined) {
+            result.ignored += 1;
+            return null;
+        }
+        const order = this.createOrder(sequence, occurredAt);
+        const previousOrder = this.lastAppliedDeviceOrder.get(homeyDeviceId);
+        if (previousOrder !== undefined && !this.isNewerOrder(order, previousOrder)) {
+            result.ignored += 1;
+            return null;
+        }
+        return { adopted, order };
+    }
+    recordDeviceOrder(homeyDeviceId, order, applied) {
+        this.lastObservedDeviceOrder.set(homeyDeviceId, this.preserveSequenceWatermark(order, this.lastObservedDeviceOrder.get(homeyDeviceId)));
+        if (applied) {
+            this.lastAppliedDeviceOrder.set(homeyDeviceId, this.preserveSequenceWatermark(order, this.lastAppliedDeviceOrder.get(homeyDeviceId)));
+        }
+    }
+    isDeviceEvent(event) {
+        return (event.type === homey_event_model_1.HomeyEventType.DEVICE_AVAILABILITY_CHANGED ||
+            event.type === homey_event_model_1.HomeyEventType.DEVICE_ADDED ||
+            event.type === homey_event_model_1.HomeyEventType.DEVICE_UPDATED ||
+            event.type === homey_event_model_1.HomeyEventType.DEVICE_REMOVED);
+    }
+    compareSequences(candidate, current) {
+        if (typeof candidate === 'number' && typeof current === 'number') {
+            return Math.sign(candidate - current);
+        }
+        if (typeof candidate === 'string' && typeof current === 'string' && candidate === current) {
+            return 0;
+        }
+        return null;
+    }
+    isValidEvent(event) {
+        switch (event.type) {
+            case homey_event_model_1.HomeyEventType.CAPABILITY_VALUE_CHANGED:
+                return (typeof event.deviceId === 'string' &&
+                    event.deviceId.length > 0 &&
+                    typeof event.capabilityId === 'string' &&
+                    event.capabilityId.length > 0 &&
+                    this.isCapabilityValue(event.value));
+            case homey_event_model_1.HomeyEventType.DEVICE_AVAILABILITY_CHANGED:
+                return typeof event.deviceId === 'string' && event.deviceId.length > 0 && typeof event.available === 'boolean';
+            case homey_event_model_1.HomeyEventType.DEVICE_ADDED:
+            case homey_event_model_1.HomeyEventType.DEVICE_UPDATED:
+            case homey_event_model_1.HomeyEventType.DEVICE_REMOVED:
+                return typeof event.deviceId === 'string' && event.deviceId.length > 0;
+            case homey_event_model_1.HomeyEventType.ZONE_ADDED:
+            case homey_event_model_1.HomeyEventType.ZONE_UPDATED:
+            case homey_event_model_1.HomeyEventType.ZONE_REMOVED:
+                return typeof event.zoneId === 'string' && event.zoneId.length > 0;
+        }
+    }
+    isCapabilityValue(value) {
+        return (value === null ||
+            typeof value === 'boolean' ||
+            typeof value === 'string' ||
+            (typeof value === 'number' && Number.isFinite(value)));
+    }
+    parseTimestamp(value) {
+        if (value === null) {
+            return null;
+        }
+        const timestamp = Date.parse(value);
+        return Number.isFinite(timestamp) ? timestamp : null;
+    }
+    emptyResult() {
+        return { updated: 0, ignored: 0, failed: 0 };
+    }
+};
+exports.HomeySynchronizerService = HomeySynchronizerService;
+__decorate([
+    (0, event_emitter_1.OnEvent)(devices_constants_1.EventType.DEVICE_CREATED),
+    (0, event_emitter_1.OnEvent)(devices_constants_1.EventType.DEVICE_UPDATED),
+    (0, event_emitter_1.OnEvent)(devices_constants_1.EventType.DEVICE_DELETED),
+    (0, event_emitter_1.OnEvent)(devices_constants_1.EventType.CHANNEL_CREATED),
+    (0, event_emitter_1.OnEvent)(devices_constants_1.EventType.CHANNEL_UPDATED),
+    (0, event_emitter_1.OnEvent)(devices_constants_1.EventType.CHANNEL_DELETED),
+    (0, event_emitter_1.OnEvent)(devices_constants_1.EventType.CHANNEL_PROPERTY_CREATED),
+    (0, event_emitter_1.OnEvent)(devices_constants_1.EventType.CHANNEL_PROPERTY_UPDATED),
+    (0, event_emitter_1.OnEvent)(devices_constants_1.EventType.CHANNEL_PROPERTY_DELETED),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], HomeySynchronizerService.prototype, "invalidateFromEntity", null);
+__decorate([
+    (0, event_emitter_1.OnEvent)(devices_constants_1.EventType.CHANNEL_PROPERTY_VALUE_SET),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [devices_homey_entity_1.HomeyChannelPropertyEntity]),
+    __metadata("design:returntype", void 0)
+], HomeySynchronizerService.prototype, "recordPersistedPropertyValue", null);
+exports.HomeySynchronizerService = HomeySynchronizerService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [devices_service_1.DevicesService,
+        channels_properties_service_1.ChannelsPropertiesService,
+        device_connectivity_service_1.DeviceConnectivityService,
+        mapping_loader_service_1.HomeyMappingLoaderService,
+        mapping_transformer_service_1.HomeyMappingTransformerService])
+], HomeySynchronizerService);
+//# sourceMappingURL=homey-synchronizer.service.js.map