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

package/dist/cjs/implementations/appliances/identifier-strategies.cjs

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentifierStrategyFactory = exports.FallbackIdentifierStrategy = exports.CompositeIdentifierStrategy = exports.CustomMetadataStrategy = exports.SerialNumberStrategy = exports.NetworkDeviceIdStrategy = void 0;
+/**
+ * Strategy that uses the network device ID as the identifier.
+ * This is the default strategy for most appliances.
+ */
+class NetworkDeviceIdStrategy {
+    name = 'networkDeviceId';
+    /**
+     * Extracts the network device ID.
+     * @param appliance The appliance (not used in this strategy)
+     * @param networkDevice The network device to get the ID from
+     * @returns The network device ID or undefined
+     */
+    extract(appliance, networkDevice) {
+        return networkDevice?.id;
+    }
+}
+exports.NetworkDeviceIdStrategy = NetworkDeviceIdStrategy;
+/**
+ * Strategy that uses the appliance's serial number as the identifier.
+ * Useful when appliances can move between network devices.
+ */
+class SerialNumberStrategy {
+    name = 'serialNumber';
+    /**
+     * Extracts the serial number from the appliance metadata.
+     * @param appliance The appliance to extract the serial number from
+     * @returns The serial number or undefined
+     */
+    extract(appliance) {
+        return appliance.metadata?.serialNumber;
+    }
+}
+exports.SerialNumberStrategy = SerialNumberStrategy;
+/**
+ * Strategy that uses a custom metadata field as the identifier.
+ * Allows using any field from the appliance metadata.
+ */
+class CustomMetadataStrategy {
+    fieldName;
+    name;
+    /**
+     * Creates a strategy that uses a custom metadata field.
+     * @param fieldName The name of the metadata field to use as identifier
+     */
+    constructor(fieldName) {
+        this.fieldName = fieldName;
+        this.name = `metadata.${String(fieldName)}`;
+    }
+    /**
+     * Extracts the custom field value from the appliance metadata.
+     * @param appliance The appliance to extract the field from
+     * @returns The field value or undefined
+     */
+    extract(appliance) {
+        const value = appliance.metadata?.[this.fieldName];
+        return value !== undefined ? String(value) : undefined;
+    }
+}
+exports.CustomMetadataStrategy = CustomMetadataStrategy;
+/**
+ * Strategy that combines multiple identifiers to create a composite key.
+ * Useful when a single identifier is not unique enough.
+ */
+class CompositeIdentifierStrategy {
+    strategies;
+    separator;
+    name;
+    /**
+     * Creates a strategy that combines multiple strategies.
+     * @param strategies The strategies to combine
+     * @param separator The separator to use between identifier parts
+     */
+    constructor(strategies, separator = ':') {
+        this.strategies = strategies;
+        this.separator = separator;
+        this.name = `composite(${strategies.map(s => s.name).join('+')})`;
+    }
+    /**
+     * Extracts and combines identifiers from multiple strategies.
+     * @param appliance The appliance to extract identifiers from
+     * @param networkDevice The network device if available
+     * @returns The combined identifier or undefined if any part is missing
+     */
+    extract(appliance, networkDevice) {
+        const parts = [];
+        for (const strategy of this.strategies) {
+            const value = strategy.extract(appliance, networkDevice);
+            if (!value) {
+                return undefined; // All parts must be present
+            }
+            parts.push(value);
+        }
+        return parts.join(this.separator);
+    }
+}
+exports.CompositeIdentifierStrategy = CompositeIdentifierStrategy;
+/**
+ * Strategy that tries multiple strategies in order and uses the first available identifier.
+ * Useful for fallback scenarios.
+ */
+class FallbackIdentifierStrategy {
+    strategies;
+    name;
+    /**
+     * Creates a strategy that tries multiple strategies in order.
+     * @param strategies The strategies to try in order
+     */
+    constructor(strategies) {
+        this.strategies = strategies;
+        this.name = `fallback(${strategies.map(s => s.name).join('|')})`;
+    }
+    /**
+     * Tries strategies in order and returns the first available identifier.
+     * @param appliance The appliance to extract identifiers from
+     * @param networkDevice The network device if available
+     * @returns The first available identifier or undefined
+     */
+    extract(appliance, networkDevice) {
+        for (const strategy of this.strategies) {
+            const value = strategy.extract(appliance, networkDevice);
+            if (value) {
+                return value;
+            }
+        }
+        return undefined;
+    }
+}
+exports.FallbackIdentifierStrategy = FallbackIdentifierStrategy;
+/**
+ * Factory class for creating common identifier strategies.
+ */
+class IdentifierStrategyFactory {
+    /**
+     * Creates the default network device ID strategy.
+     */
+    static networkDeviceId() {
+        return new NetworkDeviceIdStrategy();
+    }
+    /**
+     * Creates a serial number strategy.
+     */
+    static serialNumber() {
+        return new SerialNumberStrategy();
+    }
+    /**
+     * Creates a custom metadata field strategy.
+     * @param fieldName The metadata field to use
+     */
+    static customMetadata(fieldName) {
+        return new CustomMetadataStrategy(fieldName);
+    }
+    /**
+     * Creates a composite strategy that combines multiple identifiers.
+     * @param strategies The strategies to combine
+     * @param separator The separator between parts
+     */
+    static composite(strategies, separator) {
+        return new CompositeIdentifierStrategy(strategies, separator);
+    }
+    /**
+     * Creates a fallback strategy that tries multiple strategies in order.
+     * @param strategies The strategies to try
+     */
+    static fallback(strategies) {
+        return new FallbackIdentifierStrategy(strategies);
+    }
+    /**
+     * Creates a strategy that prefers serial number but falls back to network device ID.
+     */
+    static serialNumberOrDeviceId() {
+        return new FallbackIdentifierStrategy([
+            new SerialNumberStrategy(),
+            new NetworkDeviceIdStrategy()
+        ]);
+    }
+}
+exports.IdentifierStrategyFactory = IdentifierStrategyFactory;

package/dist/cjs/implementations/appliances/identifier-strategies.d.cts

@@ -0,0 +1,140 @@
+import type { EnyoAppliance } from "../../types/enyo-appliance.cjs";
+import type { EnyoNetworkDevice } from "../../types/enyo-network-device.cjs";
+/**
+ * Strategy interface for extracting unique identifiers from appliances.
+ * Allows flexible identification of appliances based on different criteria.
+ */
+export interface IdentifierStrategy {
+    /**
+     * Extract the unique identifier from an appliance or its associated data.
+     * @param appliance The appliance to extract the identifier from
+     * @param networkDevice Optional network device associated with the appliance
+     * @returns The extracted identifier string, or undefined if not available
+     */
+    extract(appliance: Partial<EnyoAppliance>, networkDevice?: EnyoNetworkDevice): string | undefined;
+    /**
+     * Name of the strategy for logging and debugging purposes.
+     */
+    name: string;
+}
+/**
+ * Strategy that uses the network device ID as the identifier.
+ * This is the default strategy for most appliances.
+ */
+export declare class NetworkDeviceIdStrategy implements IdentifierStrategy {
+    name: string;
+    /**
+     * Extracts the network device ID.
+     * @param appliance The appliance (not used in this strategy)
+     * @param networkDevice The network device to get the ID from
+     * @returns The network device ID or undefined
+     */
+    extract(appliance: Partial<EnyoAppliance>, networkDevice?: EnyoNetworkDevice): string | undefined;
+}
+/**
+ * Strategy that uses the appliance's serial number as the identifier.
+ * Useful when appliances can move between network devices.
+ */
+export declare class SerialNumberStrategy implements IdentifierStrategy {
+    name: string;
+    /**
+     * Extracts the serial number from the appliance metadata.
+     * @param appliance The appliance to extract the serial number from
+     * @returns The serial number or undefined
+     */
+    extract(appliance: Partial<EnyoAppliance>): string | undefined;
+}
+/**
+ * Strategy that uses a custom metadata field as the identifier.
+ * Allows using any field from the appliance metadata.
+ */
+export declare class CustomMetadataStrategy implements IdentifierStrategy {
+    private fieldName;
+    name: string;
+    /**
+     * Creates a strategy that uses a custom metadata field.
+     * @param fieldName The name of the metadata field to use as identifier
+     */
+    constructor(fieldName: keyof NonNullable<EnyoAppliance['metadata']>);
+    /**
+     * Extracts the custom field value from the appliance metadata.
+     * @param appliance The appliance to extract the field from
+     * @returns The field value or undefined
+     */
+    extract(appliance: Partial<EnyoAppliance>): string | undefined;
+}
+/**
+ * Strategy that combines multiple identifiers to create a composite key.
+ * Useful when a single identifier is not unique enough.
+ */
+export declare class CompositeIdentifierStrategy implements IdentifierStrategy {
+    private strategies;
+    private separator;
+    name: string;
+    /**
+     * Creates a strategy that combines multiple strategies.
+     * @param strategies The strategies to combine
+     * @param separator The separator to use between identifier parts
+     */
+    constructor(strategies: IdentifierStrategy[], separator?: string);
+    /**
+     * Extracts and combines identifiers from multiple strategies.
+     * @param appliance The appliance to extract identifiers from
+     * @param networkDevice The network device if available
+     * @returns The combined identifier or undefined if any part is missing
+     */
+    extract(appliance: Partial<EnyoAppliance>, networkDevice?: EnyoNetworkDevice): string | undefined;
+}
+/**
+ * Strategy that tries multiple strategies in order and uses the first available identifier.
+ * Useful for fallback scenarios.
+ */
+export declare class FallbackIdentifierStrategy implements IdentifierStrategy {
+    private strategies;
+    name: string;
+    /**
+     * Creates a strategy that tries multiple strategies in order.
+     * @param strategies The strategies to try in order
+     */
+    constructor(strategies: IdentifierStrategy[]);
+    /**
+     * Tries strategies in order and returns the first available identifier.
+     * @param appliance The appliance to extract identifiers from
+     * @param networkDevice The network device if available
+     * @returns The first available identifier or undefined
+     */
+    extract(appliance: Partial<EnyoAppliance>, networkDevice?: EnyoNetworkDevice): string | undefined;
+}
+/**
+ * Factory class for creating common identifier strategies.
+ */
+export declare class IdentifierStrategyFactory {
+    /**
+     * Creates the default network device ID strategy.
+     */
+    static networkDeviceId(): NetworkDeviceIdStrategy;
+    /**
+     * Creates a serial number strategy.
+     */
+    static serialNumber(): SerialNumberStrategy;
+    /**
+     * Creates a custom metadata field strategy.
+     * @param fieldName The metadata field to use
+     */
+    static customMetadata(fieldName: keyof NonNullable<EnyoAppliance['metadata']>): CustomMetadataStrategy;
+    /**
+     * Creates a composite strategy that combines multiple identifiers.
+     * @param strategies The strategies to combine
+     * @param separator The separator between parts
+     */
+    static composite(strategies: IdentifierStrategy[], separator?: string): CompositeIdentifierStrategy;
+    /**
+     * Creates a fallback strategy that tries multiple strategies in order.
+     * @param strategies The strategies to try
+     */
+    static fallback(strategies: IdentifierStrategy[]): FallbackIdentifierStrategy;
+    /**
+     * Creates a strategy that prefers serial number but falls back to network device ID.
+     */
+    static serialNumberOrDeviceId(): FallbackIdentifierStrategy;
+}

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

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryApplianceManager = void 0;
+const enyo_appliance_js_1 = require("../../types/enyo-appliance.cjs");
+const appliance_manager_js_1 = require("./appliance-manager.cjs");
+/**
+ * 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.
+ */
+class InMemoryApplianceManager extends appliance_manager_js_1.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 ||
+                enyo_appliance_js_1.EnyoApplianceConnectionType.Connector,
+            state: config.metadata?.state ||
+                existingAppliance?.metadata?.state ||
+                enyo_appliance_js_1.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;
+    }
+}
+exports.InMemoryApplianceManager = InMemoryApplianceManager;