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

package/dist/modules/devices/services/property-value.service.js

@@ -15,31 +15,76 @@ const extension_logger_service_1 = require("../../../common/logger/extension-log
 const storage_service_1 = require("../../storage/services/storage.service");
 const devices_constants_1 = require("../devices.constants");
 const property_value_state_model_1 = require("../models/property-value-state.model");
+const property_value_lock_service_1 = require("./property-value-lock.service");
+const property_value_source_registry_service_1 = require("./property-value-source.registry.service");
 const TREND_POINTS_COUNT = 5;
+const BOUNDED_READ_MAX_PROPERTIES = 500;
+const BOUNDED_READ_SOURCE_CHUNK_SIZE = 50;
+const BOUNDED_READ_DEFAULT_DEADLINE_MS = 750;
 let PropertyValueService = class PropertyValueService {
-    constructor(storageService) {
+    constructor(storageService, valueSourceRegistry, valueLock) {
         this.storageService = storageService;
+        this.valueSourceRegistry = valueSourceRegistry;
+        this.valueLock = valueLock;
         this.logger = (0, extension_logger_service_1.createExtensionLogger)(devices_constants_1.DEVICES_MODULE_NAME, 'PropertyValueService');
         this.valuesMap = new Map();
         this.recentValuesMap = new Map();
+        this.cacheVersions = new Map();
+        this.valueTails = new Map();
     }
-    async write(property, value) {
+    async write(property, value, valueTimestamp) {
+        const key = this.valueSourceRegistry.resolve(property);
+        return (await this.withValueLock(key, () => this.writeInternal(property, value, false, undefined, valueTimestamp)))
+            .changed;
+    }
+    async writeStrict(property, value, storageBinding) {
+        return (await this.writeStrictWithState(property, value, storageBinding)).changed;
+    }
+    async writeStrictWithState(property, value, storageBinding, valueTimestamp) {
+        const key = this.valueSourceRegistry.resolve(property);
+        return this.withValueLock(key, () => this.writeInternal(property, value, true, storageBinding, valueTimestamp));
+    }
+    async writeStrictIfPersistedDifferent(property, value, expectedPersistedState, beforeWrite, valueTimestamp) {
+        const key = this.valueSourceRegistry.resolve(property);
+        return this.withValueLock(key, async (valueLease) => {
+            const latest = await this.readLatestInternal(property, true, true, true);
+            await beforeWrite?.();
+            if (latest.state?.value === value) {
+                return { changed: false, state: latest.state };
+            }
+            if (!this.samePersistedState(latest.state, expectedPersistedState)) {
+                return { changed: false, state: latest.state };
+            }
+            if (!latest.storageBinding) {
+                throw new Error('Persisted property value read did not bind a storage backend');
+            }
+            await valueLease.assertOwned();
+            return this.writeInternal(property, value, true, latest.storageBinding, valueTimestamp);
+        });
+    }
+    async writeInternal(property, value, strict, storageBinding, valueTimestamp) {
+        const key = this.valueSourceRegistry.resolve(property);
+        if (key !== property.id) {
+            this.logger.debug(`Skipping write for projected property id=${property.id}: its value belongs to source property id=${key}`);
+            return { changed: false, state: null };
+        }
         if (value === null || value === undefined) {
-            return false;
+            return { changed: false, state: null };
         }
         if (property.invalid !== null && this.isInvalidValue(property.invalid, value)) {
             this.logger.debug(`Skipping invalid/sentinel value for property id=${property.id}: value=${value}`);
-            return false;
+            return { changed: false, state: null };
         }
-        const cached = this.valuesMap.get(property.id);
-        if (cached && cached.value === value) {
-            cached.lastUpdated = new Date().toISOString();
-            return false;
+        const cached = this.valuesMap.get(key);
+        if (!strict && cached && cached.value === value) {
+            cached.lastUpdated = (valueTimestamp ?? new Date()).toISOString();
+            this.bumpCacheVersion(key);
+            return { changed: false, state: cached };
         }
         const validationError = this.validateValue(property, value);
         if (validationError) {
             this.logger.warn(`Invalid value for property id=${property.id}: ${validationError}. Value=${JSON.stringify(value)}`);
-            return false;
+            return { changed: false, state: null };
         }
         const formattedValue = {};
         switch (property.dataType) {
@@ -61,118 +106,505 @@ let PropertyValueService = class PropertyValueService {
                 break;
             default:
                 this.logger.error(`Unsupported data type dataType=${property.dataType} id=${property.id}`);
-                return false;
+                return { changed: false, state: null };
+        }
+        const timestamp = valueTimestamp ?? new Date();
+        const now = timestamp.toISOString();
+        const point = {
+            measurement: 'property_value',
+            tags: { propertyId: key },
+            fields: formattedValue,
+            timestamp,
+        };
+        const cacheVersionAtWriteStart = this.cacheVersion(key);
+        if (strict) {
+            await this.storageService.writePointsStrict([point], storageBinding);
+            if (this.cacheVersion(key) !== cacheVersionAtWriteStart) {
+                return { changed: true, state: new property_value_state_model_1.PropertyValueState(value, now) };
+            }
         }
-        const now = new Date().toISOString();
         if (typeof value === 'number' ||
             (typeof value === 'string' && !isNaN(Number(value)) && this.isNumericDataType(property.dataType))) {
             const numValue = Number(value);
-            const recent = this.recentValuesMap.get(property.id) ?? [];
+            const recent = this.recentValuesMap.get(key) ?? [];
             recent.push(numValue);
             if (recent.length > TREND_POINTS_COUNT) {
                 recent.shift();
             }
-            this.recentValuesMap.set(property.id, recent);
+            this.recentValuesMap.set(key, recent);
         }
-        const trend = this.computeTrend(property);
+        const trend = this.computeTrend(property, key);
         const state = new property_value_state_model_1.PropertyValueState(value, now, trend);
-        this.valuesMap.set(property.id, state);
+        this.setCachedState(key, state);
+        if (strict) {
+            return { changed: true, state };
+        }
         if (!this.storageService.isConnected()) {
-            return true;
+            return { changed: true, state };
         }
         try {
-            await this.storageService.writePoints([
-                {
-                    measurement: 'property_value',
-                    tags: { propertyId: property.id },
-                    fields: formattedValue,
-                    timestamp: new Date(),
-                },
-            ]);
+            await this.storageService.writePoints([point]);
             this.logger.debug(`Value saved id=${property.id} dataType=${property.dataType} value=${value}`);
         }
         catch (error) {
             const err = error;
             this.logger.error(`Failed to write value to storage id=${property.id} dataType=${property.dataType} error=${err.message}`, err.stack);
         }
-        return true;
+        return { changed: true, state };
     }
     async readLatest(property) {
-        const cached = this.valuesMap.get(property.id);
-        if (cached) {
-            this.logger.debug(`Loaded cached value for property id=${property.id}, value=${cached.value}`);
-            return cached;
+        return (await this.readLatestInternal(property, false)).state;
+    }
+    async readLatestStrict(property) {
+        return (await this.readLatestInternal(property, true)).state;
+    }
+    async readLatestPersisted(property) {
+        return (await this.readLatestPersistedSnapshot(property)).state;
+    }
+    async readLatestPersistedSnapshot(property) {
+        const result = await this.readLatestInternal(property, true, true, true);
+        if (!result.storageBinding) {
+            throw new Error('Persisted property value read did not bind a storage backend');
+        }
+        return { state: result.state, storageBinding: result.storageBinding };
+    }
+    async readLatestManyStrict(properties) {
+        const states = new Map();
+        const missingByKey = new Map();
+        const keyByProperty = new Map();
+        for (const property of properties) {
+            const key = this.valueSourceRegistry.resolve(property);
+            keyByProperty.set(property.id, key);
+            const cached = this.valuesMap.get(key);
+            if (cached) {
+                states.set(property.id, cached);
+            }
+            else if (!missingByKey.has(key)) {
+                missingByKey.set(key, property);
+            }
+        }
+        if (missingByKey.size === 0) {
+            return states;
+        }
+        if (!this.storageService.isConnected()) {
+            throw new Error('Property value storage is unavailable');
+        }
+        const predicate = Array.from(missingByKey.keys())
+            .map((key) => `propertyId = '${this.escapeTagValue(key)}'`)
+            .join(' OR ');
+        const query = `
+        SELECT *
+        FROM property_value
+        WHERE (${predicate})
+		GROUP BY "propertyId"
+		ORDER BY time DESC
+		LIMIT ${TREND_POINTS_COUNT}
+      `;
+        try {
+            const rows = await this.storageService.queryStrict(query);
+            const rowsByKey = new Map();
+            for (const row of rows) {
+                rowsByKey.set(row.propertyId, [...(rowsByKey.get(row.propertyId) ?? []), row]);
+            }
+            for (const [key, property] of missingByKey) {
+                const propertyRows = rowsByKey.get(key) ?? [];
+                if (this.isNumericDataType(property.dataType)) {
+                    this.recentValuesMap.set(key, propertyRows
+                        .map((row) => row.numberValue)
+                        .filter((value) => value !== undefined)
+                        .reverse());
+                }
+                const state = propertyRows[0] ? this.toState(property, key, propertyRows[0]) : null;
+                if (state) {
+                    this.setCachedState(key, state);
+                }
+            }
+            for (const property of properties) {
+                if (!states.has(property.id)) {
+                    states.set(property.id, this.valuesMap.get(keyByProperty.get(property.id) ?? property.id) ?? null);
+                }
+            }
+            return states;
+        }
+        catch (error) {
+            const err = error;
+            this.logger.error(`Failed to batch read latest property values from storage error=${err.message}`, err.stack);
+            throw error;
+        }
+    }
+    async readLatestManyBounded(properties, options = {}) {
+        if (properties.length > BOUNDED_READ_MAX_PROPERTIES) {
+            throw new RangeError(`At most ${BOUNDED_READ_MAX_PROPERTIES} property values may be read at once`);
+        }
+        const startedAt = Date.now();
+        const requestedDeadlineAt = options.deadlineAt?.getTime() ?? startedAt + BOUNDED_READ_DEFAULT_DEADLINE_MS;
+        if (!Number.isFinite(requestedDeadlineAt)) {
+            throw new RangeError('Property value read deadline must be a valid date');
+        }
+        const deadlineAt = Math.min(requestedDeadlineAt, startedAt + BOUNDED_READ_DEFAULT_DEADLINE_MS);
+        const items = new Array(properties.length);
+        const sourcePropertyIds = new Array(properties.length);
+        const unresolvedBySource = new Map();
+        for (const [index, property] of properties.entries()) {
+            const sourcePropertyId = this.valueSourceRegistry.resolve(property);
+            sourcePropertyIds[index] = sourcePropertyId;
+            const cached = this.valuesMap.get(sourcePropertyId);
+            if (cached) {
+                items[index] = this.toBoundedItem(property.id, sourcePropertyId, cached, 'cache');
+                continue;
+            }
+            const group = unresolvedBySource.get(sourcePropertyId);
+            if (group) {
+                group.indexes.push(index);
+            }
+            else {
+                unresolvedBySource.set(sourcePropertyId, { property, indexes: [index] });
+            }
+        }
+        if (unresolvedBySource.size === 0) {
+            return this.buildBoundedResult(items, 'not_needed');
+        }
+        if (Date.now() >= deadlineAt) {
+            this.refreshBoundedItemsFromCache(items, properties, sourcePropertyIds);
+            this.fillUnprocessedBoundedItems(items, properties, unresolvedBySource);
+            return this.buildBoundedResult(items, 'timed_out');
         }
         if (!this.storageService.isConnected()) {
+            this.refreshBoundedItemsFromCache(items, properties, sourcePropertyIds);
+            this.fillUnprocessedBoundedItems(items, properties, unresolvedBySource);
+            return this.buildBoundedResult(items, 'disconnected');
+        }
+        const sourceEntries = [...unresolvedBySource.entries()];
+        let storageStatus = 'available';
+        for (let offset = 0; offset < sourceEntries.length; offset += BOUNDED_READ_SOURCE_CHUNK_SIZE) {
+            if (Date.now() >= deadlineAt) {
+                storageStatus = 'timed_out';
+                break;
+            }
+            const chunk = sourceEntries.slice(offset, offset + BOUNDED_READ_SOURCE_CHUNK_SIZE);
+            const query = this.buildBoundedPropertyValueQuery(chunk.map(([sourcePropertyId]) => sourcePropertyId));
+            try {
+                const queryResult = await this.queryPropertyValuesBeforeDeadline(query, deadlineAt);
+                if (queryResult === null) {
+                    storageStatus = 'timed_out';
+                    break;
+                }
+                this.applyBoundedStorageRows(items, properties, chunk, queryResult);
+                for (const [sourcePropertyId] of chunk) {
+                    unresolvedBySource.delete(sourcePropertyId);
+                }
+            }
+            catch (error) {
+                const err = error;
+                this.logger.error(`Failed to bounded-batch read latest property values error=${err.message}`, err.stack);
+                storageStatus = 'failed';
+                break;
+            }
+        }
+        this.refreshBoundedItemsFromCache(items, properties, sourcePropertyIds);
+        this.fillUnprocessedBoundedItems(items, properties, unresolvedBySource);
+        return this.buildBoundedResult(items, storageStatus);
+    }
+    buildBoundedPropertyValueQuery(sourcePropertyIds) {
+        const predicate = sourcePropertyIds
+            .map((sourcePropertyId) => `propertyId = '${this.escapeTagValue(sourcePropertyId)}'`)
+            .join(' OR ');
+        return `
+	        SELECT *
+	        FROM property_value
+	        WHERE (${predicate})
+			GROUP BY "propertyId"
+			ORDER BY time DESC
+			LIMIT ${TREND_POINTS_COUNT}
+	      `;
+    }
+    async queryPropertyValuesBeforeDeadline(query, deadlineAt) {
+        const remainingMs = deadlineAt - Date.now();
+        if (remainingMs <= 0) {
             return null;
         }
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(new Error('Property value storage query timed out')), remainingMs);
+        try {
+            return await this.storageService.queryStrict(query, { signal: controller.signal });
+        }
+        catch (error) {
+            if (controller.signal.aborted) {
+                return null;
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    applyBoundedStorageRows(items, properties, chunk, rows) {
+        const rowsBySource = new Map();
+        for (const row of rows) {
+            rowsBySource.set(row.propertyId, [...(rowsBySource.get(row.propertyId) ?? []), row]);
+        }
+        for (const [sourcePropertyId, group] of chunk) {
+            const sourceRows = rowsBySource.get(sourcePropertyId) ?? [];
+            const firstRow = sourceRows[0];
+            let storedState = firstRow ? this.toState(group.property, sourcePropertyId, firstRow) : null;
+            const concurrentCache = this.valuesMap.get(sourcePropertyId);
+            const useCache = concurrentCache !== undefined && this.isStateNewerOrEqual(concurrentCache, storedState);
+            if (!useCache && firstRow) {
+                this.updateRecentValuesFromRows(group.property, sourcePropertyId, sourceRows);
+                storedState = this.toState(group.property, sourcePropertyId, firstRow);
+            }
+            const state = useCache ? concurrentCache : storedState;
+            const source = useCache ? 'cache' : 'storage';
+            if (!useCache && storedState) {
+                this.setCachedState(sourcePropertyId, storedState);
+            }
+            for (const index of group.indexes) {
+                items[index] = this.toBoundedItem(properties[index].id, sourcePropertyId, state, source);
+            }
+        }
+    }
+    isStateNewerOrEqual(cached, stored) {
+        if (!stored) {
+            return true;
+        }
+        const cachedTime = cached.lastUpdated === null ? null : Date.parse(cached.lastUpdated);
+        const storedTime = stored.lastUpdated === null ? null : Date.parse(stored.lastUpdated);
+        if (cachedTime === null || Number.isNaN(cachedTime)) {
+            return storedTime === null || Number.isNaN(storedTime);
+        }
+        if (storedTime === null || Number.isNaN(storedTime)) {
+            return true;
+        }
+        return cachedTime >= storedTime;
+    }
+    cacheVersion(key) {
+        return this.cacheVersions.get(key) ?? 0;
+    }
+    bumpCacheVersion(key) {
+        this.cacheVersions.set(key, this.cacheVersion(key) + 1);
+    }
+    setCachedState(key, state) {
+        this.valuesMap.set(key, state);
+        this.bumpCacheVersion(key);
+    }
+    samePersistedState(left, right) {
+        return left?.value === right?.value && left?.lastUpdated === right?.lastUpdated;
+    }
+    withValueLock(key, operation) {
+        const previous = this.valueTails.get(key) ?? Promise.resolve();
+        let release = () => { };
+        const ticket = new Promise((resolve) => {
+            release = resolve;
+        });
+        const tail = previous.then(() => ticket, () => ticket);
+        this.valueTails.set(key, tail);
+        const runOperation = () => this.valueLock.runExclusive(key, operation);
+        return previous.then(runOperation, runOperation).finally(() => {
+            release();
+            if (this.valueTails.get(key) === tail) {
+                this.valueTails.delete(key);
+            }
+        });
+    }
+    updateRecentValuesFromRows(property, sourcePropertyId, rows) {
+        if (!this.isNumericDataType(property.dataType)) {
+            return;
+        }
+        this.recentValuesMap.set(sourcePropertyId, rows
+            .map((row) => row.numberValue)
+            .filter((value) => value !== undefined)
+            .reverse());
+    }
+    toBoundedItem(propertyId, sourcePropertyId, state, source) {
+        if (state === null || state.value === null) {
+            return { propertyId, sourcePropertyId, status: 'missing', source, state };
+        }
+        return {
+            propertyId,
+            sourcePropertyId,
+            status: 'available',
+            source,
+            state: state,
+        };
+    }
+    refreshBoundedItemsFromCache(items, properties, sourcePropertyIds) {
+        for (const [index, property] of properties.entries()) {
+            const sourcePropertyId = sourcePropertyIds[index];
+            const cached = this.valuesMap.get(sourcePropertyId);
+            if (!cached) {
+                continue;
+            }
+            const current = items[index];
+            if (current?.state === cached) {
+                continue;
+            }
+            if (current?.state && !this.isStateNewerOrEqual(cached, current.state)) {
+                continue;
+            }
+            items[index] = this.toBoundedItem(property.id, sourcePropertyId, cached, 'cache');
+        }
+    }
+    fillUnprocessedBoundedItems(items, properties, groups) {
+        for (const [sourcePropertyId, group] of groups) {
+            for (const index of group.indexes) {
+                if (items[index] !== undefined) {
+                    continue;
+                }
+                items[index] = {
+                    propertyId: properties[index].id,
+                    sourcePropertyId,
+                    status: 'unprocessed',
+                    source: null,
+                    state: null,
+                };
+            }
+        }
+    }
+    buildBoundedResult(items, storageStatus) {
+        const resolvedItems = items.filter((item) => item !== undefined);
+        const cacheCount = resolvedItems.filter((item) => item.source === 'cache').length;
+        const storageCount = resolvedItems.filter((item) => item.source === 'storage').length;
+        const missingCount = resolvedItems.filter((item) => item.status === 'missing').length;
+        const unprocessedCount = resolvedItems.filter((item) => item.status === 'unprocessed').length;
+        const availableCount = resolvedItems.filter((item) => item.status === 'available').length;
+        const unknownCount = missingCount + unprocessedCount;
+        const freshnessUnknownCount = resolvedItems.filter((item) => item.status === 'available' &&
+            (item.state.lastUpdated === null || Number.isNaN(Date.parse(item.state.lastUpdated)))).length;
+        const timestamps = resolvedItems
+            .filter((item) => item.status === 'available' && item.state?.lastUpdated !== null)
+            .map((item) => item.state?.lastUpdated)
+            .filter((timestamp) => timestamp !== undefined && !Number.isNaN(Date.parse(timestamp)))
+            .sort((left, right) => Date.parse(left) - Date.parse(right));
+        return {
+            items: resolvedItems,
+            requestedCount: items.length,
+            availableCount,
+            unknownCount,
+            complete: unknownCount === 0,
+            storageStatus,
+            cacheCount,
+            storageCount,
+            missingCount,
+            unprocessedCount,
+            oldestLastUpdated: timestamps[0] ?? null,
+            newestLastUpdated: timestamps[timestamps.length - 1] ?? null,
+            freshnessUnknownCount,
+        };
+    }
+    async readLatestInternal(property, strict, bypassCache = false, activeBackendOnly = false) {
+        const key = this.valueSourceRegistry.resolve(property);
+        const cacheVersionAtQueryStart = this.cacheVersion(key);
+        const cached = this.valuesMap.get(key);
+        if (!bypassCache && cached) {
+            this.logger.debug(`Loaded cached value for property id=${property.id}, value=${cached.value}`);
+            return { state: cached };
+        }
+        if (!this.storageService.isConnected()) {
+            if (strict) {
+                throw new Error('Property value storage is unavailable');
+            }
+            return { state: null };
+        }
         try {
             const query = `
         SELECT * FROM property_value
-        WHERE propertyId = '${property.id}'
+        WHERE propertyId = '${key}'
         ORDER BY time DESC
         LIMIT ${TREND_POINTS_COUNT}
       `;
             this.logger.debug(`Fetching latest value id=${property.id}`);
-            const result = await this.storageService.query(query);
+            const boundResult = activeBackendOnly
+                ? await this.storageService.queryActiveStrictBound(query)
+                : null;
+            const result = boundResult
+                ? boundResult.rows
+                : strict
+                    ? await this.storageService.queryStrict(query)
+                    : await this.storageService.query(query);
             if (!result.length) {
                 this.logger.debug(`No stored value found for id=${property.id}`);
-                return null;
+                if (bypassCache && this.cacheVersion(key) === cacheVersionAtQueryStart) {
+                    this.valuesMap.delete(key);
+                    this.recentValuesMap.delete(key);
+                    this.bumpCacheVersion(key);
+                }
+                return { state: null, storageBinding: boundResult?.binding };
             }
             const latest = result[0];
-            let parsedValue = null;
-            switch (property.dataType) {
-                case devices_constants_1.DataTypeType.ENUM:
-                case devices_constants_1.DataTypeType.STRING:
-                    parsedValue = latest.stringValue ?? null;
-                    break;
-                case devices_constants_1.DataTypeType.BOOL:
-                    parsedValue = latest.stringValue != null ? latest.stringValue === 'true' : null;
-                    break;
-                case devices_constants_1.DataTypeType.CHAR:
-                case devices_constants_1.DataTypeType.UCHAR:
-                case devices_constants_1.DataTypeType.SHORT:
-                case devices_constants_1.DataTypeType.USHORT:
-                case devices_constants_1.DataTypeType.INT:
-                case devices_constants_1.DataTypeType.UINT:
-                    parsedValue = latest.numberValue != null ? Math.round(latest.numberValue) : null;
-                    break;
-                case devices_constants_1.DataTypeType.FLOAT:
-                    parsedValue = latest.numberValue ?? null;
-                    break;
-                default:
-                    parsedValue = null;
-            }
-            const lastUpdated = latest.time
-                ? latest.time instanceof Date
-                    ? latest.time.toISOString()
-                    : String(latest.time)
-                : null;
-            if (this.isNumericDataType(property.dataType) && result.length >= 1) {
-                const recentValues = [];
-                for (let i = result.length - 1; i >= 0; i--) {
-                    const val = result[i].numberValue;
-                    if (val != null) {
-                        recentValues.push(val);
+            const cacheUnchanged = this.cacheVersion(key) === cacheVersionAtQueryStart;
+            if (cacheUnchanged) {
+                if (this.isNumericDataType(property.dataType) && result.length >= 1) {
+                    const recentValues = [];
+                    for (let i = result.length - 1; i >= 0; i--) {
+                        const val = result[i].numberValue;
+                        if (val != null) {
+                            recentValues.push(val);
+                        }
                     }
+                    this.recentValuesMap.set(key, recentValues);
                 }
-                this.recentValuesMap.set(property.id, recentValues);
             }
-            const trend = this.computeTrend(property);
-            const state = new property_value_state_model_1.PropertyValueState(parsedValue, lastUpdated, trend);
-            this.logger.debug(`Read latest value id=${property.id} dataType=${property.dataType} value=${parsedValue}`);
-            this.valuesMap.set(property.id, state);
-            return state;
+            const state = this.toState(property, key, latest);
+            this.logger.debug(`Read latest value id=${property.id} dataType=${property.dataType} value=${state.value}`);
+            if (cacheUnchanged) {
+                this.setCachedState(key, state);
+            }
+            return { state, storageBinding: boundResult?.binding };
         }
         catch (error) {
             const err = error;
             this.logger.error(`Failed to read latest value from storage id=${property.id} error=${err.message}`, err.stack);
-            return null;
+            if (strict) {
+                throw error;
+            }
+            return { state: null };
         }
     }
+    toState(property, key, latest) {
+        let parsedValue;
+        switch (property.dataType) {
+            case devices_constants_1.DataTypeType.ENUM:
+            case devices_constants_1.DataTypeType.STRING:
+                parsedValue = latest.stringValue ?? null;
+                break;
+            case devices_constants_1.DataTypeType.BOOL:
+                parsedValue = latest.stringValue != null ? latest.stringValue === 'true' : null;
+                break;
+            case devices_constants_1.DataTypeType.CHAR:
+            case devices_constants_1.DataTypeType.UCHAR:
+            case devices_constants_1.DataTypeType.SHORT:
+            case devices_constants_1.DataTypeType.USHORT:
+            case devices_constants_1.DataTypeType.INT:
+            case devices_constants_1.DataTypeType.UINT:
+                parsedValue = latest.numberValue != null ? Math.round(latest.numberValue) : null;
+                break;
+            case devices_constants_1.DataTypeType.FLOAT:
+                parsedValue = latest.numberValue ?? null;
+                break;
+            default:
+                parsedValue = null;
+        }
+        const lastUpdated = latest.time
+            ? latest.time instanceof Date
+                ? latest.time.toISOString()
+                : String(latest.time)
+            : null;
+        return new property_value_state_model_1.PropertyValueState(parsedValue, lastUpdated, this.computeTrend(property, key));
+    }
+    escapeTagValue(value) {
+        return value.replaceAll('\\', '\\\\').replaceAll("'", "\\'");
+    }
     async delete(property) {
+        const key = this.valueSourceRegistry.resolve(property);
+        return this.withValueLock(key, () => this.deleteInternal(property, key));
+    }
+    async deleteInternal(property, key) {
+        if (key !== property.id) {
+            return;
+        }
         this.valuesMap.delete(property.id);
         this.recentValuesMap.delete(property.id);
+        this.bumpCacheVersion(property.id);
         if (!this.storageService.isConnected()) {
             return;
         }
@@ -186,11 +618,28 @@ let PropertyValueService = class PropertyValueService {
             this.logger.error(`Failed to delete property data from storage propertyId=${property.id} error=${err.message}`, err.stack);
         }
     }
-    computeTrend(property) {
+    async deleteSinceStrict(property, since) {
+        const key = this.valueSourceRegistry.resolve(property);
+        return this.withValueLock(key, () => this.deleteSinceStrictInternal(property, since, key));
+    }
+    async deleteSinceStrictInternal(property, since, key) {
+        if (key !== property.id) {
+            return;
+        }
+        if (!this.storageService.isConnected()) {
+            throw new Error('Property value storage is unavailable');
+        }
+        this.valuesMap.delete(key);
+        this.recentValuesMap.delete(key);
+        this.bumpCacheVersion(key);
+        const firstTransientMillisecond = new Date(since.getTime() + 1);
+        await this.storageService.queryStrict(`DELETE FROM property_value WHERE propertyId = '${this.escapeTagValue(key)}' AND time >= '${firstTransientMillisecond.toISOString()}'`);
+    }
+    computeTrend(property, key) {
         if (!this.isNumericDataType(property.dataType)) {
             return null;
         }
-        const recent = this.recentValuesMap.get(property.id);
+        const recent = this.recentValuesMap.get(key);
         if (!recent || recent.length < 2) {
             return null;
         }
@@ -289,6 +738,8 @@ let PropertyValueService = class PropertyValueService {
 exports.PropertyValueService = PropertyValueService;
 exports.PropertyValueService = PropertyValueService = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [storage_service_1.StorageService])
+    __metadata("design:paramtypes", [storage_service_1.StorageService,
+        property_value_source_registry_service_1.PropertyValueSourceRegistryService,
+        property_value_lock_service_1.PropertyValueLockService])
 ], PropertyValueService);
 //# sourceMappingURL=property-value.service.js.map