v2c-any 0.1.4 → 0.1.5

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

@@ -1,3 +1,4 @@
+import { AbstractExecutableService } from '../service/abstract-executable-service.js';
 import { MqttService } from '../service/mqtt-service.js';
 /**
  * Factory for creating an MQTT service that manages energy publishing.
@@ -45,17 +46,18 @@ export class MqttServiceFactory {
             energyType: 'solar',
             callbacks,
         });
-        return {
-            async start() {
+        const mqttExecutableService = class extends AbstractExecutableService {
+            async doStart() {
                 await mqttService.start();
                 await gridEnergyPublisher.start();
                 await sunEnergyPublisher.start();
-            },
-            async stop() {
+            }
+            async doStop() {
                 await sunEnergyPublisher.stop();
                 await gridEnergyPublisher.stop();
                 await mqttService.stop();
-            },
+            }
         };
+        return new mqttExecutableService();
     }
 }

package/dist/index.js

@@ -10,29 +10,27 @@ import { MqttPushExecutableServiceFactory } from './factory/mqtt-push-executable
 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();
+    let executableServiceFactory;
     switch (configuration.provider) {
         case 'rest': {
-            const emulatorFactory = new RestServiceFactory(new EM1StatusProviderFactory(devicesProviderRegistry));
-            service = emulatorFactory.create(configuration);
+            executableServiceFactory = new RestServiceFactory(new EM1StatusProviderFactory(devicesProviderRegistry));
             break;
         }
         case 'mqtt': {
             const mqttFeedExecutableServiceFactory = new MqttFeedExecutableServiceFactory(new MqttPullExecutableServiceFactory(devicesProviderRegistry, devicesAdapterRegistry), new MqttPushExecutableServiceFactory(devicesAdapterRegistry));
-            const mqttFactory = new MqttServiceFactory(mqttFeedExecutableServiceFactory);
-            service = mqttFactory.create(configuration);
+            executableServiceFactory = new MqttServiceFactory(mqttFeedExecutableServiceFactory);
             break;
         }
     }
+    const service = executableServiceFactory.create(configuration);
     const shutdown = async () => {
         try {
             logger.info('Shutting down...');
-            if (service)
-                await service.stop();
+            await service?.stop();
             logger.info('Shutdown complete');
         }
         catch (err) {

package/dist/service/abstract-executable-service.js

@@ -0,0 +1,48 @@
+import { logger } from '../utils/logger.js';
+/**
+ * Abstract base class for executable services.
+ * Provides idempotent start/stop lifecycle management with state tracking.
+ * Subclasses implement the actual service logic via doStart() and doStop() hooks.
+ */
+export class AbstractExecutableService {
+    constructor() {
+        /**
+         * Internal state flag tracking whether the service is currently started.
+         * @private
+         */
+        this._started = false;
+    }
+    /**
+     * Returns whether the service is currently started.
+     * @returns true if the service has been started and not yet stopped
+     */
+    get started() {
+        return this._started;
+    }
+    /**
+     * Starts the service.
+     * Idempotent: calling start() on an already-started service is a no-op with a warning.
+     * @returns A promise that resolves when the service has successfully started
+     */
+    async start() {
+        if (this._started) {
+            logger.warn(`Service is already started`);
+            return;
+        }
+        await this.doStart();
+        this._started = true;
+    }
+    /**
+     * Stops the service.
+     * Idempotent: calling stop() on an already-stopped service is a no-op with a warning.
+     * @returns A promise that resolves when the service has successfully stopped
+     */
+    async stop() {
+        if (!this._started) {
+            logger.warn(`Service is not started`);
+            return;
+        }
+        await this.doStop();
+        this._started = false;
+    }
+}

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

@@ -1,5 +1,6 @@
 import { logger } from '../utils/logger.js';
 import { createMqttClient } from '../utils/mqtt.js';
+import { AbstractExecutableService } from './abstract-executable-service.js';
 /**
  * Service that bridges MQTT messages to a typed callback via an adapter.
  * Subscribes to a topic, parses incoming messages, adapts them, and forwards
@@ -8,7 +9,7 @@ import { createMqttClient } from '../utils/mqtt.js';
  * @template InputMessage - The raw message type received from MQTT
  * @template Payload - The adapted payload type passed to the callback
  */
-export class MqttBridgeService {
+export class MqttBridgeService extends AbstractExecutableService {
     /**
      * Creates a new MQTT bridge service.
      * @param properties - MQTT connection and subscription details
@@ -16,6 +17,7 @@ export class MqttBridgeService {
      * @param adapter - Adapter that transforms raw MQTT messages to the payload type
      */
     constructor(properties, callbackProperties, adapter) {
+        super();
         this.properties = properties;
         this.callbackProperties = callbackProperties;
         this.adapter = adapter;
@@ -25,7 +27,7 @@ export class MqttBridgeService {
      * Starts the bridge: connects to the broker, subscribes, and wires message handling.
      * @returns A promise that resolves when the subscription is active
      */
-    async start() {
+    async doStart() {
         logger.info('Starting MQTT bridge service');
         this.client = await createMqttClient(this.properties.url);
         this.client.on('message', (topic, message) => {
@@ -49,12 +51,10 @@ export class MqttBridgeService {
      * Stops the bridge: disconnects the MQTT client and clears resources.
      * @returns A promise that resolves when the client has disconnected
      */
-    async stop() {
+    async doStop() {
         logger.info('Stopping MQTT bridge service');
-        if (this.client) {
-            await this.client.endAsync();
-            this.client = null;
-        }
+        await this.client?.endAsync();
+        this.client = null;
         logger.info('MQTT bridge service stopped');
     }
 }

package/dist/service/mqtt-service.js

@@ -1,5 +1,6 @@
 import { logger } from '../utils/logger.js';
 import { createMqttClient } from '../utils/mqtt.js';
+import { AbstractExecutableService } from './abstract-executable-service.js';
 /**
  * MQTT topic for publishing solar power readings.
  */
@@ -12,12 +13,13 @@ 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 {
+export class MqttService extends AbstractExecutableService {
     /**
      * Creates a new MQTT service.
      * @param properties - MQTT connection properties including broker URL
      */
     constructor(properties) {
+        super();
         this.properties = properties;
         this.client = null;
     }
@@ -53,12 +55,8 @@ export class MqttService {
      * @returns A promise that resolves when the client is connected
      * @throws {Error} If the client is already started
      */
-    async start() {
+    async doStart() {
         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);
         logger.info('MQTT client started');
     }
@@ -67,15 +65,10 @@ export class MqttService {
      * @returns A promise that resolves when the client is disconnected
      * @throws {Error} If the client is not started
      */
-    async stop() {
+    async doStop() {
         logger.info('Stopping MQTT mode');
-        const client = this.client;
+        await this.client?.endAsync();
         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

@@ -1,20 +1,21 @@
+import { AbstractExecutableService } from './abstract-executable-service.js';
 /**
  * A no-operation implementation of ExecutableService.
  * Used as a null-object pattern implementation when no actual service execution is needed.
  */
-class NoOpExecutableService {
+class NoOpExecutableService extends AbstractExecutableService {
     /**
      * Starts the service (no-op implementation).
      * @returns An immediately resolved promise
      */
-    async start() {
+    async doStart() {
         // no-op
     }
     /**
      * Stops the service (no-op implementation).
      * @returns An immediately resolved promise
      */
-    async stop() {
+    async doStop() {
         // no-op
     }
 }

package/dist/service/pull-push-service.js

@@ -1,4 +1,5 @@
 import { logger } from '../utils/logger.js';
+import { AbstractExecutableService } from './abstract-executable-service.js';
 /**
  * Periodic pull-then-push service.
  * Fetches data from a `Provider` at a fixed interval and forwards it via a callback.
@@ -6,7 +7,7 @@ import { logger } from '../utils/logger.js';
  *
  * @template Payload - The type of data provided and pushed
  */
-export class PullPushService {
+export class PullPushService extends AbstractExecutableService {
     /**
      * Creates a new pull/push service.
      * @param provider - Source `Provider` that supplies data
@@ -14,6 +15,7 @@ export class PullPushService {
      * @param callbackProperties - Callback container invoked with fetched data
      */
     constructor(provider, intervalMs, callbackProperties) {
+        super();
         this.provider = provider;
         this.intervalMs = intervalMs;
         this.callbackProperties = callbackProperties;
@@ -24,7 +26,7 @@ export class PullPushService {
      * @returns A promise that resolves once the service starts
      * @throws {Error} If the service is already started
      */
-    async start() {
+    doStart() {
         if (this.abortController) {
             throw new Error('Adapter already started');
         }
@@ -37,7 +39,7 @@ export class PullPushService {
      * Stops periodic polling if running.
      * @returns A promise that resolves once the service stops
      */
-    stop() {
+    doStop() {
         this.abortController?.abort();
         this.abortController = null;
         return Promise.resolve();

package/dist/service/rest-service.js

@@ -4,13 +4,15 @@ import { expectationBodySchema } from '../schema/expectation-body.js';
 import { statusQuerySchema } from '../schema/status-query.js';
 import { logger } from '../utils/logger.js';
 import { FixedValueProvider } from '../provider/fixed-value-provider.js';
+import { AbstractExecutableService } from './abstract-executable-service.js';
 /**
  * REST service that exposes Shelly EM1-like endpoints for energy status.
  * Provides health checks, mock expectation updates, and status queries for grid and solar.
  * Implements the executable service lifecycle to start and stop the HTTP server.
  */
-export class RestService {
+export class RestService extends AbstractExecutableService {
     constructor(gridEnergyProvider, solarEnergyProvider, properties) {
+        super();
         this.gridEnergyProvider = gridEnergyProvider;
         this.solarEnergyProvider = solarEnergyProvider;
         this.properties = properties;
@@ -41,7 +43,8 @@ export class RestService {
      * - `GET /rpc/EM1.GetStatus` fetch status for a given id
      * @returns A promise that resolves when the server is listening
      */
-    async start() {
+    async doStart() {
+        logger.info('Starting REST service...');
         const app = Fastify({
             loggerInstance: logger,
             disableRequestLogging: true,
@@ -92,16 +95,17 @@ export class RestService {
         //app.post('/rpc/EM1.GetStatus', async () => app.inject({ method: 'GET', url: '/rpc/EM1.GetStatus' }).then(r => r.json()));
         await app.listen({ port: this.properties.port, host: '0.0.0.0' });
         logger.info({ port: this.properties.port }, 'Listening');
+        logger.info('REST service started');
     }
     /**
      * Stops the REST server if running.
      * @returns A promise that resolves when the server has closed
      */
-    async stop() {
-        logger.info('Stopping emulator...');
+    async doStop() {
+        logger.info('Stopping REST service...');
         if (this.app) {
             await this.app.close();
         }
-        return Promise.resolve();
+        logger.info('REST service stopped');
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "v2c-any",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "type": "module",
   "description": "V2C device adapter and MQTT publisher (Shelly EM1 compatible)",
   "main": "dist/index.js",