v2c-any 0.1.2

package/dist/factory/mqtt-service-factory.js

@@ -0,0 +1,61 @@
+import { MqttService } from '../service/mqtt-service.js';
+/**
+ * Factory for creating an MQTT service that manages energy publishing.
+ * Composes MQTT client setup with grid and solar feed publishers,
+ * exposing a unified executable service with start/stop lifecycle.
+ */
+export class MqttServiceFactory {
+    /**
+     * Creates a new MQTT service factory.
+     * @param mqttFeedExecutableServiceFactory - Factory to build feed publishers (pull/push) for energy data
+     */
+    constructor(mqttFeedExecutableServiceFactory) {
+        this.mqttFeedExecutableServiceFactory = mqttFeedExecutableServiceFactory;
+    }
+    /**
+     * Creates an executable MQTT service wired to publish grid and solar power.
+     * Initializes the MQTT client and constructs feed publishers based on configuration.
+     *
+     * @param configuration - MQTT provider configuration including broker URL, device, and meter feeds
+     * @returns An ExecutableService with coordinated start/stop for MQTT client and feed publishers
+     */
+    create(configuration) {
+        const mqttService = new MqttService({ url: configuration.properties.url });
+        const callbacks = {
+            grid: {
+                callback: async (power) => {
+                    await mqttService.pushGridPower(power);
+                },
+            },
+            sun: {
+                callback: async (power) => {
+                    await mqttService.pushSunPower(power);
+                },
+            },
+        };
+        const gridEnergyPublisher = this.mqttFeedExecutableServiceFactory.create({
+            configuration: configuration.properties.meters.grid,
+            device: configuration.properties.device,
+            energyType: 'grid',
+            callbacks,
+        });
+        const sunEnergyPublisher = this.mqttFeedExecutableServiceFactory.create({
+            configuration: configuration.properties.meters.solar,
+            device: configuration.properties.device,
+            energyType: 'solar',
+            callbacks,
+        });
+        return {
+            async start() {
+                await mqttService.start();
+                await gridEnergyPublisher.start();
+                await sunEnergyPublisher.start();
+            },
+            async stop() {
+                await sunEnergyPublisher.stop();
+                await gridEnergyPublisher.stop();
+                await mqttService.stop();
+            },
+        };
+    }
+}

package/dist/factory/rest-service-factory.js

@@ -0,0 +1,35 @@
+import { RestService } from '../service/rest-service.js';
+/**
+ * Factory for creating REST services that expose energy data.
+ * Composes grid and solar energy providers based on configuration and
+ * returns an executable REST service instance.
+ */
+export class RestServiceFactory {
+    /**
+     * Creates a new REST service factory.
+     * @param em1StatusProviderFactory - Factory used to build device-specific energy providers
+     */
+    constructor(em1StatusProviderFactory) {
+        this.em1StatusProviderFactory = em1StatusProviderFactory;
+    }
+    /**
+     * Creates an executable REST service using configured grid and solar providers.
+     * @param configuration - REST provider configuration including device and meter setups
+     * @returns An ExecutableService that serves energy data over HTTP
+     */
+    create(configuration) {
+        const gridEnergyProvider = this.em1StatusProviderFactory.create({
+            energyType: 'grid',
+            device: configuration.properties.device,
+            configuration: configuration.properties.meters.grid,
+        });
+        const solarEnergyProvider = this.em1StatusProviderFactory.create({
+            energyType: 'solar',
+            device: configuration.properties.device,
+            configuration: configuration.properties.meters.solar,
+        });
+        return new RestService(gridEnergyProvider, solarEnergyProvider, {
+            port: configuration.properties.port,
+        });
+    }
+}

package/dist/index.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+import { devicesAdapterRegistry, devicesProviderRegistry, loadDeviceModules, } from './application-context.js';
+import { ConfigurationLoader } from './configuration/configuration-loader.js';
+import { ConfigurationValidator } from './configuration/configuration-validator.js';
+import { logger } from './utils/logger.js';
+import { MqttFeedExecutableServiceFactory } from './factory/mqtt-feed-executable-service-factory.js';
+import { EM1StatusProviderFactory } from './factory/em1-status-provider-factory.js';
+import { MqttPullExecutableServiceFactory } from './factory/mqtt-pull-executable-service-factory.js';
+import { MqttPushExecutableServiceFactory } from './factory/mqtt-push-executable-service-factory.js';
+import { RestServiceFactory } from './factory/rest-service-factory.js';
+import { MqttServiceFactory } from './factory/mqtt-service-factory.js';
+async function main() {
+    let service = null;
+    await loadDeviceModules();
+    const configurationValidator = new ConfigurationValidator();
+    const configurationLoader = new ConfigurationLoader(configurationValidator);
+    const configuration = await configurationLoader.load();
+    switch (configuration.provider) {
+        case 'rest': {
+            const emulatorFactory = new RestServiceFactory(new EM1StatusProviderFactory(devicesProviderRegistry));
+            service = emulatorFactory.create(configuration);
+            break;
+        }
+        case 'mqtt': {
+            const mqttFeedExecutableServiceFactory = new MqttFeedExecutableServiceFactory(new MqttPullExecutableServiceFactory(devicesProviderRegistry, devicesAdapterRegistry), new MqttPushExecutableServiceFactory(devicesAdapterRegistry));
+            const mqttFactory = new MqttServiceFactory(mqttFeedExecutableServiceFactory);
+            service = mqttFactory.create(configuration);
+            break;
+        }
+    }
+    await service.start();
+    const shutdown = async () => {
+        try {
+            logger.info('Shutting down...');
+            if (service)
+                await service.stop();
+        }
+        finally {
+            process.exit(0);
+        }
+    };
+    logger.info('Application started successfully');
+    process.on('SIGINT', () => {
+        shutdown().catch((err) => logger.error(err, 'Error during shutdown'));
+    });
+    process.on('SIGTERM', () => {
+        shutdown().catch((err) => logger.error(err, 'Error during shutdown'));
+    });
+}
+main().catch((err) => {
+    logger.error(err, 'Fatal error occurred');
+    process.exit(1);
+});

package/dist/provider/adapter-provider.js

@@ -0,0 +1,54 @@
+/**
+ * Provider that wraps another provider and adapts its output to a different type.
+ * Implements the decorator pattern to add transformation capability to any provider.
+ *
+ * @template T - The input type from the wrapped provider
+ * @template K - The output type after adaptation
+ */
+export class AdapterProvider {
+    /**
+     * Creates a new adapter provider.
+     * @param provider - The underlying provider that supplies the source data
+     * @param adapter - The adapter that transforms the provider's output from type T to type K
+     */
+    constructor(provider, adapter) {
+        this.provider = provider;
+        this.adapter = adapter;
+    }
+    /**
+     * Gets data from the provider and adapts it to the target type.
+     * @returns A promise that resolves to the adapted data of type K
+     */
+    async get() {
+        const value = await this.provider.get();
+        return this.adapter.adapt(value);
+    }
+}
+/**
+ * Factory for creating AdapterProvider instances.
+ * Combines a provider factory with an adapter to create providers with transformation capability.
+ *
+ * @template Options - The configuration options type for the provider factory
+ * @template T - The intermediate type provided by the wrapped provider factory
+ * @template K - The final output type after adaptation
+ */
+export class AdapterProviderFactory {
+    /**
+     * Creates a new adapter provider factory.
+     * @param providerFactory - Factory to create providers that supply source data
+     * @param adapter - Adapter to transform the provider's output
+     */
+    constructor(providerFactory, adapter) {
+        this.providerFactory = providerFactory;
+        this.adapter = adapter;
+    }
+    /**
+     * Creates an AdapterProvider instance with the specified options.
+     * @param options - Configuration options for the wrapped provider factory
+     * @returns An AdapterProvider that supplies adapted data
+     */
+    create(options) {
+        const provider = this.providerFactory.create(options);
+        return new AdapterProvider(provider, this.adapter);
+    }
+}

package/dist/provider/factory.js

@@ -0,0 +1 @@
+export {};

package/dist/provider/fixed-value-provider.js

@@ -0,0 +1,54 @@
+/**
+ * Provider that returns a fixed, pre-configured value.
+ * Useful for testing, default fallbacks, or static data scenarios.
+ * The value can be updated at runtime through the setter.
+ *
+ * @template T - The type of value this provider supplies
+ */
+export class FixedValueProvider {
+    /**
+     * Gets the current fixed value.
+     * @returns The stored value, or undefined if not set
+     */
+    get value() {
+        return this._value;
+    }
+    /**
+     * Sets the fixed value to be returned by this provider.
+     * @param value - The value to store and return on subsequent calls
+     */
+    set value(value) {
+        this._value = value;
+    }
+    /**
+     * Gets the fixed value asynchronously.
+     * @returns A promise that resolves to the stored value
+     */
+    get() {
+        return Promise.resolve(this._value);
+    }
+}
+/**
+ * Factory for creating FixedValueProvider instances.
+ * Simplifies instantiation of providers with pre-configured static values.
+ *
+ * @template T - The type of value the created providers will supply
+ */
+export class FixedValueProviderFactory {
+    /**
+     * Creates a new fixed value provider factory.
+     * @param properties - Configuration containing the fixed value to provide
+     */
+    constructor(properties) {
+        this.properties = properties;
+    }
+    /**
+     * Creates a FixedValueProvider with the configured value.
+     * @returns A FixedValueProvider initialized with the configured value
+     */
+    create() {
+        const provider = new FixedValueProvider();
+        provider.value = this.properties.value;
+        return provider;
+    }
+}

package/dist/provider/provider-factory.js

@@ -0,0 +1 @@
+export {};

package/dist/provider/provider.js

@@ -0,0 +1 @@
+export {};

package/dist/registry/registry.js

@@ -0,0 +1,27 @@
+/**
+ * Generic registry for storing and retrieving key-value pairs.
+ * Provides a centralized store for managing instances of a specific type.
+ *
+ * @template T - The type of values stored in this registry
+ */
+export class Registry {
+    constructor() {
+        this.values = new Map();
+    }
+    /**
+     * Registers a value with the given key in the registry.
+     * @param key - The unique identifier for the value
+     * @param value - The value to store
+     */
+    register(key, value) {
+        this.values.set(key, value);
+    }
+    /**
+     * Retrieves a value from the registry by its key.
+     * @param key - The unique identifier of the value to retrieve
+     * @returns The stored value, or undefined if the key is not found
+     */
+    get(key) {
+        return this.values.get(key);
+    }
+}

package/dist/schema/configuration.js

@@ -0,0 +1,7 @@
+import { mqttProviderSchema } from './mqtt-configuration.js';
+import { restProviderSchema } from './rest-configuration.js';
+import z from 'zod';
+export const configurationSchema = z.discriminatedUnion('provider', [
+    restProviderSchema,
+    mqttProviderSchema,
+]);

package/dist/schema/expectation-body.js

@@ -0,0 +1,15 @@
+export const expectationBodySchema = {
+    type: 'object',
+    properties: {
+        voltage: { type: 'number' },
+        current: { type: 'number' },
+        act_power: { type: 'number' },
+        aprt_power: { type: 'number' },
+        pf: { type: 'number' },
+        freq: { type: 'number' },
+        calibration: { type: 'string' },
+        errors: { type: 'array', items: { type: 'string' } },
+        flags: { type: 'array', items: { type: 'string' } },
+    },
+    required: ['calibration'],
+};

package/dist/schema/mqtt-configuration.js

@@ -0,0 +1,62 @@
+import z from 'zod';
+export const energyInformationSchema = z.object({
+    power: z.number(),
+});
+export const mqttPushBridgeFeedSchema = z
+    .object({
+    url: z.string(),
+    topic: z.string(),
+})
+    .loose();
+export const mqttPushFeedSchema = z.discriminatedUnion('type', [
+    z.object({
+        type: z.literal('bridge'),
+        properties: mqttPushBridgeFeedSchema,
+    }),
+    z.object({ type: z.literal('off') }),
+]);
+export const mqttPullMockFeedSchema = z
+    .object({
+    interval: z.number().int().nonnegative(),
+    value: energyInformationSchema.optional(),
+})
+    .loose();
+export const mqttPullAdapterFeedSchema = z
+    .object({
+    interval: z.number().int().nonnegative(),
+    ip: z.string(),
+})
+    .loose();
+export const mqttPullFeedSchema = z.discriminatedUnion('type', [
+    z.object({
+        type: z.literal('adapter'),
+        properties: mqttPullAdapterFeedSchema,
+    }),
+    z.object({
+        type: z.literal('mock'),
+        properties: mqttPullMockFeedSchema,
+    }),
+    z.object({ type: z.literal('off') }),
+]);
+export const mqttFeedModeSchema = z.discriminatedUnion('mode', [
+    z.object({
+        mode: z.literal('pull'),
+        feed: mqttPullFeedSchema,
+    }),
+    z.object({
+        mode: z.literal('push'),
+        feed: mqttPushFeedSchema,
+    }),
+]);
+export const mqttMetersSchema = z.object({
+    grid: mqttFeedModeSchema,
+    solar: mqttFeedModeSchema,
+});
+export const mqttProviderSchema = z.object({
+    provider: z.literal('mqtt'),
+    properties: z.object({
+        url: z.string(),
+        device: z.string(),
+        meters: mqttMetersSchema,
+    }),
+});

package/dist/schema/rest-configuration.js

@@ -0,0 +1,73 @@
+import z from 'zod';
+// EM1 status (used by mock emulator response)
+export const em1StatusSchema = z.object({
+    /**
+     * Id of the EM1 component instance
+     */
+    id: z.number(),
+    /**
+     * Current measurement value, [A]
+     */
+    current: z.number().optional(),
+    /**
+     * Voltage measurement value, [V]
+     */
+    voltage: z.number().optional(),
+    /**
+     * Active power measurement value, [W]
+     */
+    act_power: z.number().optional(),
+    /**
+     * Apparent power measurement value, [VA] (if applicable)
+     */
+    aprt_power: z.number().optional(),
+    /**
+     * Power factor measurement value (if applicable)
+     */
+    pf: z.number().optional(),
+    /**
+     * Network frequency measurement value (if applicable)
+     */
+    freq: z.number().optional(),
+    /**
+     * Indicates factory calibration or which EM1:id is the source for calibration
+     */
+    calibration: z.string(),
+    /**
+     * EM1 component error conditions. May contain power_meter_failure, out_of_range:act_power, out_of_range:aprt_power, out_of_range:voltage, out_of_range:current or ct_type_not_set. Present in status only if not empty.
+     */
+    errors: z.array(z.string()).optional(),
+    /**
+     * Communicates present conditions, shown if at least one flag is set. Depending on component capabilites may contain: count_disabled
+     */
+    flags: z.array(z.string()).optional(),
+});
+export const restAdapterFeedSchema = z.object({ ip: z.string() }).loose();
+export const restMockFeedSchema = z
+    .object({ value: em1StatusSchema.optional() })
+    .loose();
+export const restFeedSchema = z.object({
+    feed: z.discriminatedUnion('type', [
+        z.object({
+            type: z.literal('adapter'),
+            properties: restAdapterFeedSchema,
+        }),
+        z.object({
+            type: z.literal('mock'),
+            properties: restMockFeedSchema.optional(),
+        }),
+        z.object({ type: z.literal('off') }),
+    ]),
+});
+export const restMetersSchema = z.object({
+    grid: restFeedSchema,
+    solar: restFeedSchema,
+});
+export const restProviderSchema = z.object({
+    provider: z.literal('rest'),
+    properties: z.object({
+        port: z.number().int().positive(),
+        device: z.string(),
+        meters: restMetersSchema,
+    }),
+});

package/dist/schema/status-query.js

@@ -0,0 +1,7 @@
+export const statusQuerySchema = {
+    type: 'object',
+    properties: {
+        id: { type: 'number' },
+    },
+    required: ['id'],
+};

package/dist/service/executable-service.js

@@ -0,0 +1 @@
+export {};

package/dist/service/mqtt-bridge-service.js

@@ -0,0 +1,55 @@
+import { logger } from '../utils/logger.js';
+import { createMqttClient } from '../utils/mqtt.js';
+/**
+ * Service that bridges MQTT messages to a typed callback via an adapter.
+ * Subscribes to a topic, parses incoming messages, adapts them, and forwards
+ * the adapted payload to the provided callback.
+ *
+ * @template InputMessage - The raw message type received from MQTT
+ * @template Payload - The adapted payload type passed to the callback
+ */
+export class MqttBridgeService {
+    /**
+     * Creates a new MQTT bridge service.
+     * @param properties - MQTT connection and subscription details
+     * @param callbackProperties - Callback container invoked with adapted payload
+     * @param adapter - Adapter that transforms raw MQTT messages to the payload type
+     */
+    constructor(properties, callbackProperties, adapter) {
+        this.properties = properties;
+        this.callbackProperties = callbackProperties;
+        this.adapter = adapter;
+        this.client = null;
+    }
+    /**
+     * Starts the bridge: connects to the broker, subscribes, and wires message handling.
+     * @returns A promise that resolves when the subscription is active
+     */
+    async start() {
+        this.client = await createMqttClient(this.properties.url);
+        this.client.on('message', (topic, message) => {
+            if (topic === this.properties.topic) {
+                const data = JSON.parse(message.toString());
+                this.adapter
+                    .adapt(data)
+                    .then(async (adaptedData) => {
+                    await this.callbackProperties.callback(adaptedData);
+                })
+                    .catch((error) => {
+                    logger.error(error, `Error occurred while processing message`);
+                });
+            }
+        });
+        await this.client.subscribeAsync(this.properties.topic);
+    }
+    /**
+     * Stops the bridge: disconnects the MQTT client and clears resources.
+     * @returns A promise that resolves when the client has disconnected
+     */
+    async stop() {
+        if (this.client) {
+            await this.client.endAsync();
+            this.client = null;
+        }
+    }
+}

package/dist/service/mqtt-service.js

@@ -0,0 +1,79 @@
+import { logger } from '../utils/logger.js';
+import { createMqttClient } from '../utils/mqtt.js';
+/**
+ * MQTT topic for publishing solar power readings.
+ */
+const SUN_POWER_TOPIC = 'trydan_v2c_sun_power';
+/**
+ * MQTT topic for publishing grid power readings.
+ */
+const GRID_POWER_TOPIC = 'trydan_v2c_grid_power';
+/**
+ * Service that publishes energy readings to an MQTT broker.
+ * Manages MQTT client lifecycle and exposes methods to push grid and solar power values.
+ */
+export class MqttService {
+    /**
+     * Creates a new MQTT service.
+     * @param properties - MQTT connection properties including broker URL
+     */
+    constructor(properties) {
+        this.properties = properties;
+        this.client = null;
+    }
+    /**
+     * Publishes a grid power reading to the MQTT broker.
+     * @param power - Power value in Watts
+     */
+    async pushGridPower(power) {
+        await this.pushReading(power, GRID_POWER_TOPIC);
+    }
+    /**
+     * Publishes a solar power reading to the MQTT broker.
+     * @param power - Power value in Watts
+     */
+    async pushSunPower(power) {
+        await this.pushReading(power, SUN_POWER_TOPIC);
+    }
+    /**
+     * Publishes a numeric reading to a specific MQTT topic.
+     * @param value - Numeric value to publish
+     * @param topic - MQTT topic to publish to
+     */
+    async pushReading(value, topic) {
+        if (!this.client) {
+            logger.error('MQTT client not initialized');
+            throw new Error('MQTT client not initialized');
+        }
+        logger.debug({ value, topic }, 'Publishing MQTT message');
+        await this.client.publishAsync(topic, String(value));
+    }
+    /**
+     * Starts the MQTT client connection.
+     * @returns A promise that resolves when the client is connected
+     * @throws {Error} If the client is already started
+     */
+    async start() {
+        logger.info('Starting MQTT mode');
+        if (this.client) {
+            logger.error('MQTT client already started');
+            throw new Error('MQTT client already started');
+        }
+        this.client = await createMqttClient(this.properties.url);
+    }
+    /**
+     * Stops the MQTT client connection.
+     * @returns A promise that resolves when the client is disconnected
+     * @throws {Error} If the client is not started
+     */
+    async stop() {
+        const client = this.client;
+        this.client = null;
+        if (!client) {
+            logger.error('MQTT client not started');
+            throw new Error('MQTT client not started');
+        }
+        await client.endAsync();
+        logger.info('MQTT client disconnected');
+    }
+}

package/dist/service/no-op-executable-service.js

@@ -0,0 +1,25 @@
+/**
+ * A no-operation implementation of ExecutableService.
+ * Used as a null-object pattern implementation when no actual service execution is needed.
+ */
+class NoOpExecutableService {
+    /**
+     * Starts the service (no-op implementation).
+     * @returns An immediately resolved promise
+     */
+    async start() {
+        // no-op
+    }
+    /**
+     * Stops the service (no-op implementation).
+     * @returns An immediately resolved promise
+     */
+    async stop() {
+        // no-op
+    }
+}
+/**
+ * Singleton instance of the no-operation executable service.
+ * Use this when a service instance is required but no actual execution is needed.
+ */
+export const noOpExecutableService = new NoOpExecutableService();