@enyo-energy/energy-app-sdk 0.0.38 → 0.0.39

package/dist/implementations/appliances/in-memory-appliance-manager.js

@@ -0,0 +1,277 @@
+import { EnyoApplianceConnectionType, EnyoApplianceStateEnum } from "../../types/enyo-appliance.js";
+import { ApplianceManager } from "./appliance-manager.js";
+/**
+ * Demo implementation of ApplianceManager that stores all data in memory.
+ * This class provides the same interface as ApplianceManager but doesn't
+ * use energyApp.useAppliances() for persistence.
+ */
+export class InMemoryApplianceManager extends ApplianceManager {
+    memoryStore = new Map();
+    nextId = 1;
+    networkDevicesStore = new Map();
+    /**
+     * Creates a new DemoApplianceManager instance.
+     * @param energyApp The EnergyApp instance (not used for persistence in demo)
+     * @param config Configuration options for the manager
+     */
+    constructor(energyApp, config) {
+        super(energyApp, config);
+    }
+    /**
+     * Creates or updates an appliance in memory.
+     * @param config The appliance configuration
+     * @param existingApplianceId Optional ID of an existing appliance to update
+     * @returns The ID of the created or updated appliance
+     */
+    async createOrUpdateAppliance(config, existingApplianceId) {
+        const applianceId = existingApplianceId || `appliance_${this.nextId++}`;
+        // Build network device IDs list
+        const networkDeviceIds = config.networkDevices?.map(d => d.id) ?? [];
+        // Get existing metadata if updating
+        const existingAppliance = existingApplianceId ? this.memoryStore.get(existingApplianceId) : null;
+        // Merge metadata with defaults and existing values
+        const metadata = {
+            connectionType: config.metadata?.connectionType ||
+                existingAppliance?.metadata?.connectionType ||
+                EnyoApplianceConnectionType.Connector,
+            state: config.metadata?.state ||
+                existingAppliance?.metadata?.state ||
+                EnyoApplianceStateEnum.Connected,
+            ...config.metadata
+        };
+        // Build appliance data
+        const applianceData = {
+            id: applianceId,
+            name: config.name,
+            type: config.type,
+            networkDeviceIds,
+            metadata,
+            ...(config.topology && { topology: config.topology })
+        };
+        // Add type-specific metadata
+        if (config.typeMetadata) {
+            Object.assign(applianceData, config.typeMetadata);
+        }
+        // Save to memory store
+        this.memoryStore.set(applianceId, applianceData);
+        // Store network devices if provided
+        if (config.networkDevices) {
+            this.networkDevicesStore.set(applianceId, config.networkDevices);
+        }
+        // Update cache
+        this.updateCache(applianceData, config.networkDevices?.[0]);
+        console.log(`[DEMO] ${existingApplianceId ? 'Updated' : 'Created'} appliance ${applianceId} of type ${config.type}`);
+        return applianceId;
+    }
+    /**
+     * Gets an appliance by ID from memory.
+     * @param applianceId The ID of the appliance
+     * @returns The appliance or null if not found
+     */
+    async getApplianceById(applianceId) {
+        return this.memoryStore.get(applianceId) || null;
+    }
+    /**
+     * Gets all appliances from memory.
+     * @returns Array of all appliances
+     */
+    async getAllAppliances() {
+        return Array.from(this.memoryStore.values());
+    }
+    /**
+     * Gets network devices associated with an appliance.
+     * @param appliance The appliance
+     * @returns Array of network devices
+     */
+    async getNetworkDevicesForApplianceDemo(appliance) {
+        return this.networkDevicesStore.get(appliance.id) || [];
+    }
+    /**
+     * Finds appliances by their identifier using the configured strategy.
+     * @param identifier The identifier to search for
+     * @returns Array of matching appliances
+     */
+    async findByIdentifier(identifier) {
+        const matches = [];
+        const strategy = this.getIdentifierStrategy();
+        for (const appliance of this.memoryStore.values()) {
+            const networkDevices = await this.getNetworkDevicesForApplianceDemo(appliance);
+            const extractedId = strategy.extract(appliance, networkDevices[0]);
+            if (extractedId === identifier) {
+                matches.push(appliance);
+                this.updateCache(appliance, networkDevices[0]);
+            }
+        }
+        return matches;
+    }
+    /**
+     * Finds an appliance using multiple strategies.
+     * @param searchValue The value to search for
+     * @param strategies Array of strategies to try
+     * @returns The first matching result or undefined
+     */
+    async findWithStrategies(searchValue, strategies) {
+        for (const strategy of strategies) {
+            for (const appliance of this.memoryStore.values()) {
+                const networkDevices = await this.getNetworkDevicesForApplianceDemo(appliance);
+                const identifier = strategy.extract(appliance, networkDevices[0]);
+                if (identifier === searchValue) {
+                    return {
+                        appliance,
+                        identifier,
+                        strategy: strategy.name
+                    };
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Gets all appliances of a specific type.
+     * @param type The appliance type to filter by
+     * @returns Array of appliances of the specified type
+     */
+    async getAppliancesByType(type) {
+        return Array.from(this.memoryStore.values()).filter(a => a.type === type);
+    }
+    /**
+     * Updates the state of an appliance in memory.
+     * @param applianceId The ID of the appliance to update
+     * @param connectionType The new connection type
+     * @param state The new state
+     */
+    async updateApplianceState(applianceId, connectionType, state) {
+        const appliance = this.memoryStore.get(applianceId);
+        if (appliance) {
+            appliance.metadata = {
+                ...appliance.metadata,
+                connectionType,
+                state
+            };
+            this.memoryStore.set(applianceId, appliance);
+            this.updateCache(appliance);
+            console.log(`[DEMO] Updated appliance ${applianceId} state to ${state}`);
+        }
+        else {
+            throw new Error(`Appliance ${applianceId} not found`);
+        }
+    }
+    /**
+     * Updates metadata for an appliance in memory.
+     * @param applianceId The ID of the appliance
+     * @param metadata The metadata to update
+     */
+    async updateApplianceMetadata(applianceId, metadata) {
+        const appliance = this.memoryStore.get(applianceId);
+        if (appliance) {
+            appliance.metadata = {
+                ...appliance.metadata,
+                ...metadata
+            };
+            this.memoryStore.set(applianceId, appliance);
+            this.updateCache(appliance);
+            console.log(`[DEMO] Updated metadata for appliance ${applianceId}`);
+        }
+        else {
+            throw new Error(`Appliance ${applianceId} not found`);
+        }
+    }
+    /**
+     * Removes an appliance from memory.
+     * @param applianceId The ID of the appliance to remove
+     */
+    async removeAppliance(applianceId) {
+        if (this.memoryStore.has(applianceId)) {
+            this.memoryStore.delete(applianceId);
+            this.networkDevicesStore.delete(applianceId);
+            // Clean up cache (from parent class)
+            this.clearCache();
+            console.log(`[DEMO] Removed appliance ${applianceId}`);
+        }
+        else {
+            throw new Error(`Appliance ${applianceId} not found`);
+        }
+    }
+    /**
+     * Performs a bulk update on multiple appliances in memory.
+     * @param updates Array of updates to perform
+     * @returns Results of the bulk update operation
+     */
+    async bulkUpdate(updates) {
+        const succeeded = [];
+        const failed = [];
+        for (const update of updates) {
+            try {
+                const appliance = this.memoryStore.get(update.applianceId);
+                if (appliance) {
+                    const updatedAppliance = {
+                        ...appliance,
+                        ...update.data,
+                        id: appliance.id // Ensure ID is preserved
+                    };
+                    this.memoryStore.set(update.applianceId, updatedAppliance);
+                    this.updateCache(updatedAppliance);
+                    succeeded.push(update.applianceId);
+                }
+                else {
+                    failed.push(update.applianceId);
+                }
+            }
+            catch (error) {
+                console.error(`[DEMO] Bulk update failed for ${update.applianceId}: ${error}`);
+                failed.push(update.applianceId);
+            }
+        }
+        console.log(`[DEMO] Bulk update completed: ${succeeded.length} succeeded, ${failed.length} failed`);
+        return { succeeded, failed };
+    }
+    /**
+     * Gets statistics about the managed appliances in memory.
+     * @returns Statistics object
+     */
+    async getStatistics() {
+        const appliances = Array.from(this.memoryStore.values());
+        const byType = {};
+        const byState = {};
+        for (const appliance of appliances) {
+            // Count by type
+            byType[appliance.type] = (byType[appliance.type] ?? 0) + 1;
+            // Count by state
+            const state = appliance.metadata?.state ?? 'unknown';
+            byState[state] = (byState[state] ?? 0) + 1;
+        }
+        return {
+            total: appliances.length,
+            byType,
+            byState,
+            cached: this.memoryStore.size
+        };
+    }
+    /**
+     * Refreshes the cache with all appliances from memory.
+     */
+    async refreshCache() {
+        this.clearCache();
+        for (const appliance of this.memoryStore.values()) {
+            const networkDevices = await this.getNetworkDevicesForApplianceDemo(appliance);
+            this.updateCache(appliance, networkDevices[0]);
+        }
+    }
+    /**
+     * Clears all data from memory (for testing purposes).
+     */
+    clearAllData() {
+        this.memoryStore.clear();
+        this.networkDevicesStore.clear();
+        this.clearCache();
+        this.nextId = 1;
+        console.log('[DEMO] All data cleared from memory');
+    }
+    /**
+     * Gets the current size of the memory store.
+     * @returns The number of appliances in memory
+     */
+    getMemoryStoreSize() {
+        return this.memoryStore.size;
+    }
+}

package/dist/implementations/data-bus/demo-data-bus.d.ts

@@ -0,0 +1,111 @@
+import { EnergyAppDataBus, EnergyAppDataBusSendDataOptions } from "../../packages/energy-app-data-bus.js";
+import { EnyoDataBusMessage, EnyoDataBusMessageAnswer, EnyoDataBusMessageEnum } from "../../types/enyo-data-bus-value.js";
+/**
+ * Demo implementation of EnergyAppDataBus that logs messages to console
+ * and maintains an in-memory message history and listener registry.
+ */
+export declare class DemoDataBus implements EnergyAppDataBus {
+    private enableConsoleLogging;
+    private messageHistory;
+    private listeners;
+    private nextListenerId;
+    private maxHistorySize;
+    /**
+     * Creates a new DemoDataBus instance.
+     * @param enableConsoleLogging Whether to log messages to console (default: true)
+     * @param maxHistorySize Maximum number of messages to keep in history (default: 1000)
+     */
+    constructor(enableConsoleLogging?: boolean, maxHistorySize?: number);
+    /**
+     * Sends messages to the data bus (logs to console and notifies listeners).
+     * @param messages Array of messages to send
+     * @param options Optional send options (not used in demo)
+     */
+    sendMessage(messages: EnyoDataBusMessage[], options?: EnergyAppDataBusSendDataOptions): void;
+    /**
+     * Sends an answer message to the data bus.
+     * @param answer The answer message to send
+     * @param options Optional send options (not used in demo)
+     */
+    sendAnswer(answer: EnyoDataBusMessageAnswer, options?: EnergyAppDataBusSendDataOptions): void;
+    /**
+     * Registers a listener for specific message types.
+     * @param types Array of message types to listen for
+     * @param listener Callback function to invoke when matching messages are received
+     * @returns Listener ID that can be used to unsubscribe
+     */
+    listenForMessages(types: EnyoDataBusMessageEnum[], listener: (entry: EnyoDataBusMessage) => void): string;
+    /**
+     * Unsubscribes a listener from the data bus.
+     * @param listenerId The ID of the listener to unsubscribe
+     */
+    unsubscribe(listenerId: string): void;
+    /**
+     * Adds a message to the history, maintaining the maximum size limit.
+     * @param message The message to add to history
+     */
+    private addToHistory;
+    /**
+     * Notifies all registered listeners that match the message type.
+     * @param message The message to notify listeners about
+     */
+    private notifyListeners;
+    /**
+     * Gets the message history.
+     * @param limit Optional limit on the number of messages to return
+     * @returns Array of messages from history
+     */
+    getMessageHistory(limit?: number): EnyoDataBusMessage[];
+    /**
+     * Gets messages of specific types from history.
+     * @param types Array of message types to filter by
+     * @param limit Optional limit on the number of messages to return
+     * @returns Filtered array of messages
+     */
+    getMessagesByType(types: EnyoDataBusMessageEnum[], limit?: number): EnyoDataBusMessage[];
+    /**
+     * Gets messages for a specific appliance from history.
+     * @param applianceId The appliance ID to filter by
+     * @param limit Optional limit on the number of messages to return
+     * @returns Filtered array of messages
+     */
+    getMessagesByAppliance(applianceId: string, limit?: number): EnyoDataBusMessage[];
+    /**
+     * Clears the message history.
+     */
+    clearHistory(): void;
+    /**
+     * Gets the current number of registered listeners.
+     * @returns The number of active listeners
+     */
+    getListenerCount(): number;
+    /**
+     * Gets information about all registered listeners.
+     * @returns Array of listener information
+     */
+    getListenerInfo(): Array<{
+        id: string;
+        types: EnyoDataBusMessageEnum[];
+    }>;
+    /**
+     * Enables or disables console logging.
+     * @param enabled Whether to enable console logging
+     */
+    setConsoleLogging(enabled: boolean): void;
+    /**
+     * Simulates receiving a message from an external source.
+     * This is useful for testing listeners without actually sending messages.
+     * @param message The message to simulate receiving
+     */
+    simulateIncomingMessage(message: EnyoDataBusMessage): void;
+    /**
+     * Gets statistics about the data bus usage.
+     * @returns Statistics object
+     */
+    getStatistics(): {
+        totalMessages: number;
+        messagesByType: Record<string, number>;
+        activeListeners: number;
+        messagesInLastHour: number;
+    };
+}

package/dist/implementations/data-bus/demo-data-bus.js

@@ -0,0 +1,242 @@
+/**
+ * Demo implementation of EnergyAppDataBus that logs messages to console
+ * and maintains an in-memory message history and listener registry.
+ */
+export class DemoDataBus {
+    enableConsoleLogging;
+    messageHistory = [];
+    listeners = new Map();
+    nextListenerId = 1;
+    maxHistorySize = 1000;
+    /**
+     * Creates a new DemoDataBus instance.
+     * @param enableConsoleLogging Whether to log messages to console (default: true)
+     * @param maxHistorySize Maximum number of messages to keep in history (default: 1000)
+     */
+    constructor(enableConsoleLogging = true, maxHistorySize) {
+        this.enableConsoleLogging = enableConsoleLogging;
+        if (maxHistorySize !== undefined) {
+            this.maxHistorySize = maxHistorySize;
+        }
+    }
+    /**
+     * Sends messages to the data bus (logs to console and notifies listeners).
+     * @param messages Array of messages to send
+     * @param options Optional send options (not used in demo)
+     */
+    sendMessage(messages, options) {
+        for (const message of messages) {
+            // Log to console if enabled
+            if (this.enableConsoleLogging) {
+                console.log('[DEMO DataBus] Message sent:', {
+                    id: message.id,
+                    type: message.message,
+                    applianceId: message.applianceId,
+                    timestamp: message.timestampIso,
+                    data: message.data
+                });
+            }
+            // Add to history
+            this.addToHistory(message);
+            // Notify listeners
+            this.notifyListeners(message);
+        }
+    }
+    /**
+     * Sends an answer message to the data bus.
+     * @param answer The answer message to send
+     * @param options Optional send options (not used in demo)
+     */
+    sendAnswer(answer, options) {
+        // Log to console if enabled
+        if (this.enableConsoleLogging) {
+            console.log('[DEMO DataBus] Answer sent:', {
+                id: answer.id,
+                type: answer.message,
+                status: answer.data.status,
+                applianceId: answer.applianceId,
+                timestamp: answer.timestampIso
+            });
+        }
+        // Add to history
+        this.addToHistory(answer);
+        // Notify listeners
+        this.notifyListeners(answer);
+    }
+    /**
+     * Registers a listener for specific message types.
+     * @param types Array of message types to listen for
+     * @param listener Callback function to invoke when matching messages are received
+     * @returns Listener ID that can be used to unsubscribe
+     */
+    listenForMessages(types, listener) {
+        const listenerId = `listener_${this.nextListenerId++}`;
+        this.listeners.set(listenerId, {
+            types,
+            callback: listener
+        });
+        if (this.enableConsoleLogging) {
+            console.log(`[DEMO DataBus] Listener ${listenerId} registered for types:`, types);
+        }
+        return listenerId;
+    }
+    /**
+     * Unsubscribes a listener from the data bus.
+     * @param listenerId The ID of the listener to unsubscribe
+     */
+    unsubscribe(listenerId) {
+        if (this.listeners.has(listenerId)) {
+            const listener = this.listeners.get(listenerId);
+            this.listeners.delete(listenerId);
+            if (this.enableConsoleLogging) {
+                console.log(`[DEMO DataBus] Listener ${listenerId} unsubscribed`);
+            }
+        }
+        else {
+            console.warn(`[DEMO DataBus] Attempted to unsubscribe non-existent listener: ${listenerId}`);
+        }
+    }
+    /**
+     * Adds a message to the history, maintaining the maximum size limit.
+     * @param message The message to add to history
+     */
+    addToHistory(message) {
+        this.messageHistory.push(message);
+        // Trim history if it exceeds the maximum size
+        if (this.messageHistory.length > this.maxHistorySize) {
+            this.messageHistory = this.messageHistory.slice(-this.maxHistorySize);
+        }
+    }
+    /**
+     * Notifies all registered listeners that match the message type.
+     * @param message The message to notify listeners about
+     */
+    notifyListeners(message) {
+        for (const [listenerId, listener] of this.listeners.entries()) {
+            if (listener.types.includes(message.message)) {
+                try {
+                    listener.callback(message);
+                    if (this.enableConsoleLogging) {
+                        console.log(`[DEMO DataBus] Notified listener ${listenerId} of ${message.message}`);
+                    }
+                }
+                catch (error) {
+                    console.error(`[DEMO DataBus] Error in listener ${listenerId}:`, error);
+                }
+            }
+        }
+    }
+    /**
+     * Gets the message history.
+     * @param limit Optional limit on the number of messages to return
+     * @returns Array of messages from history
+     */
+    getMessageHistory(limit) {
+        if (limit && limit > 0) {
+            return this.messageHistory.slice(-limit);
+        }
+        return [...this.messageHistory];
+    }
+    /**
+     * Gets messages of specific types from history.
+     * @param types Array of message types to filter by
+     * @param limit Optional limit on the number of messages to return
+     * @returns Filtered array of messages
+     */
+    getMessagesByType(types, limit) {
+        const filtered = this.messageHistory.filter(msg => types.includes(msg.message));
+        if (limit && limit > 0) {
+            return filtered.slice(-limit);
+        }
+        return filtered;
+    }
+    /**
+     * Gets messages for a specific appliance from history.
+     * @param applianceId The appliance ID to filter by
+     * @param limit Optional limit on the number of messages to return
+     * @returns Filtered array of messages
+     */
+    getMessagesByAppliance(applianceId, limit) {
+        const filtered = this.messageHistory.filter(msg => msg.applianceId === applianceId);
+        if (limit && limit > 0) {
+            return filtered.slice(-limit);
+        }
+        return filtered;
+    }
+    /**
+     * Clears the message history.
+     */
+    clearHistory() {
+        this.messageHistory = [];
+        if (this.enableConsoleLogging) {
+            console.log('[DEMO DataBus] Message history cleared');
+        }
+    }
+    /**
+     * Gets the current number of registered listeners.
+     * @returns The number of active listeners
+     */
+    getListenerCount() {
+        return this.listeners.size;
+    }
+    /**
+     * Gets information about all registered listeners.
+     * @returns Array of listener information
+     */
+    getListenerInfo() {
+        return Array.from(this.listeners.entries()).map(([id, listener]) => ({
+            id,
+            types: listener.types
+        }));
+    }
+    /**
+     * Enables or disables console logging.
+     * @param enabled Whether to enable console logging
+     */
+    setConsoleLogging(enabled) {
+        this.enableConsoleLogging = enabled;
+        console.log(`[DEMO DataBus] Console logging ${enabled ? 'enabled' : 'disabled'}`);
+    }
+    /**
+     * Simulates receiving a message from an external source.
+     * This is useful for testing listeners without actually sending messages.
+     * @param message The message to simulate receiving
+     */
+    simulateIncomingMessage(message) {
+        if (this.enableConsoleLogging) {
+            console.log('[DEMO DataBus] Simulating incoming message:', {
+                id: message.id,
+                type: message.message,
+                applianceId: message.applianceId
+            });
+        }
+        // Add to history
+        this.addToHistory(message);
+        // Notify listeners
+        this.notifyListeners(message);
+    }
+    /**
+     * Gets statistics about the data bus usage.
+     * @returns Statistics object
+     */
+    getStatistics() {
+        const now = new Date();
+        const oneHourAgo = new Date(now.getTime() - 60 * 60 * 1000);
+        const messagesByType = {};
+        let messagesInLastHour = 0;
+        for (const message of this.messageHistory) {
+            // Count by type
+            messagesByType[message.message] = (messagesByType[message.message] ?? 0) + 1;
+            // Count messages in last hour
+            if (new Date(message.timestampIso) > oneHourAgo) {
+                messagesInLastHour++;
+            }
+        }
+        return {
+            totalMessages: this.messageHistory.length,
+            messagesByType,
+            activeListeners: this.listeners.size,
+            messagesInLastHour
+        };
+    }
+}

package/dist/types/enyo-data-bus-value.d.ts

@@ -109,6 +109,7 @@ export declare enum EnyoDataBusMessageEnum {
     AggregatedStateUpdateV1 = "AggregatedStateUpdateV1",
     EnergyTariffUpdateV1 = "EnergyTariffUpdateV1"
 }
+export type EnyoDataBusMessageResolution = '10s' | '30s' | '1m' | '15m' | '1h' | '1d' | 'dynamic';
 export interface EnyoDataBusMessage {
     id: string;
     message: EnyoDataBusMessageEnum;
@@ -118,7 +119,7 @@ export interface EnyoDataBusMessage {
     clockId?: string;
     timestampIso: string;
     /** If you just forward events that occur, use dynamic as resolution */
-    resolution?: '10s' | '30s' | '1m' | '15m' | '1h' | '1d' | 'dynamic';
+    resolution?: EnyoDataBusMessageResolution;
     data: object;
 }
 export interface EnyoDataBusMessageAnswer extends EnyoDataBusMessage {

package/dist/version.d.ts

@@ -5,7 +5,7 @@
 /**
  * Current version of the enyo Energy App SDK.
  */
-export declare const SDK_VERSION = "0.0.38";
+export declare const SDK_VERSION = "0.0.39";
 /**
  * Gets the current SDK version.
  * @returns The semantic version string of the SDK

package/dist/version.js

@@ -5,7 +5,7 @@
 /**
  * Current version of the enyo Energy App SDK.
  */
-export const SDK_VERSION = '0.0.38';
+export const SDK_VERSION = '0.0.39';
 /**
  * Gets the current SDK version.
  * @returns The semantic version string of the SDK

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@enyo-energy/energy-app-sdk",
-  "version": "0.0.38",
+  "version": "0.0.39",
   "description": "enyo Energy App SDK",
   "type": "module",
   "main": "dist/index.js",