v2c-any 0.1.2

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

@@ -0,0 +1,81 @@
+import { logger } from '../utils/logger.js';
+/**
+ * Periodic pull-then-push service.
+ * Fetches data from a `Provider` at a fixed interval and forwards it via a callback.
+ * Implements start/stop lifecycle control.
+ *
+ * @template Payload - The type of data provided and pushed
+ */
+export class PullPushService {
+    /**
+     * Creates a new pull/push service.
+     * @param provider - Source `Provider` that supplies data
+     * @param intervalMs - Polling interval in milliseconds
+     * @param callbackProperties - Callback container invoked with fetched data
+     */
+    constructor(provider, intervalMs, callbackProperties) {
+        this.provider = provider;
+        this.intervalMs = intervalMs;
+        this.callbackProperties = callbackProperties;
+        this.abortController = null;
+    }
+    /**
+     * Starts periodic polling and an immediate initial cycle.
+     * @returns A promise that resolves once the service starts
+     * @throws {Error} If the service is already started
+     */
+    async start() {
+        if (this.abortController) {
+            throw new Error('Adapter already started');
+        }
+        this.abortController = new AbortController();
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        this.run(this.abortController.signal);
+        return Promise.resolve();
+    }
+    /**
+     * Stops periodic polling if running.
+     * @returns A promise that resolves once the service stops
+     */
+    stop() {
+        this.abortController?.abort();
+        this.abortController = null;
+        return Promise.resolve();
+    }
+    /**
+     * Main async loop that runs cycles until aborted.
+     * @param signal - AbortSignal to control loop cancellation
+     */
+    async run(signal) {
+        // Create a single abort promise that resolves when signal is aborted
+        const abortPromise = new Promise((resolve) => {
+            signal.addEventListener('abort', () => resolve(), { once: true });
+        });
+        while (!signal.aborted) {
+            try {
+                await this.cycle();
+            }
+            catch (err) {
+                logger.error(err, 'Error during pull-push cycle');
+            }
+            // Wait for either the interval or abort signal
+            if (!signal.aborted) {
+                const timeoutPromise = new Promise((resolve) => {
+                    setTimeout(resolve, this.intervalMs);
+                });
+                await Promise.race([timeoutPromise, abortPromise]);
+            }
+        }
+    }
+    /**
+     * Single poll-and-push cycle.
+     * Retrieves data from the provider and forwards it to the callback when present.
+     */
+    async cycle() {
+        const data = await this.provider.get();
+        if (data) {
+            logger.info({ data }, 'Pushing data');
+            await this.callbackProperties.callback(data);
+        }
+    }
+}

package/dist/service/rest-service.js

@@ -0,0 +1,107 @@
+import Fastify from 'fastify';
+import { ILLEGAL_MODE_RESPONSE_TEMPLATE, UNKNOWN_ID_RESPONSE_TEMPLATE, } from '../template/response.js';
+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';
+/**
+ * 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 {
+    constructor(gridEnergyProvider, solarEnergyProvider, properties) {
+        this.gridEnergyProvider = gridEnergyProvider;
+        this.solarEnergyProvider = solarEnergyProvider;
+        this.properties = properties;
+        this.app = null;
+    }
+    /**
+     * Resolves the energy provider by numeric identifier.
+     * 0 → grid, 1 → solar.
+     * @param id - Provider identifier (0 for grid, 1 for solar)
+     * @returns The matching provider or null if unknown
+     */
+    getEnergyProviderById(id) {
+        let targetEmulator = null;
+        switch (id) {
+            case 0: // Grid
+                targetEmulator = this.gridEnergyProvider;
+                break;
+            case 1: // Solar
+                targetEmulator = this.solarEnergyProvider;
+                break;
+        }
+        return targetEmulator;
+    }
+    /**
+     * Starts the REST server and registers endpoints.
+     * - `GET /health` simple OK
+     * - `POST /expectaction` set mocked status (mock mode only)
+     * - `GET /rpc/EM1.GetStatus` fetch status for a given id
+     * @returns A promise that resolves when the server is listening
+     */
+    async start() {
+        const app = Fastify({
+            loggerInstance: logger,
+            disableRequestLogging: true,
+        });
+        this.app = app;
+        // Simple health
+        app.get('/health', () => ({ ok: true }));
+        app.post('/expectaction', { schema: { body: expectationBodySchema } }, async (request, reply) => {
+            const body = request.body;
+            const id = body.id;
+            const targetEmulator = this.getEnergyProviderById(id);
+            if (!targetEmulator) {
+                reply.status(400);
+                return reply.send(UNKNOWN_ID_RESPONSE_TEMPLATE(id));
+            }
+            if (!(targetEmulator instanceof FixedValueProvider)) {
+                reply.status(400);
+                return reply.send(ILLEGAL_MODE_RESPONSE_TEMPLATE(id, 'mock'));
+            }
+            const mockedEmulator = targetEmulator;
+            mockedEmulator.value = body;
+            reply.status(200);
+        });
+        // Shelly EM1-like endpoint
+        app.get('/rpc/EM1.GetStatus', { schema: { querystring: statusQuerySchema } }, async (request, reply) => {
+            app.log.debug({ query: request.query }, 'Received request');
+            const { id } = request.query;
+            const energyProvider = this.getEnergyProviderById(id);
+            if (!energyProvider) {
+                reply.status(400);
+                return reply.send(UNKNOWN_ID_RESPONSE_TEMPLATE(id));
+            }
+            try {
+                const result = await energyProvider.get();
+                if (result == undefined) {
+                    reply.status(404);
+                    return reply.send(UNKNOWN_ID_RESPONSE_TEMPLATE(id));
+                }
+                reply.status(200);
+                return reply.send(result);
+            }
+            catch (err) {
+                reply.status(500);
+                return reply.send({ code: -1, message: err.message });
+            }
+        });
+        // Alias for JSON-RPC style (POST)
+        //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');
+    }
+    /**
+     * Stops the REST server if running.
+     * @returns A promise that resolves when the server has closed
+     */
+    async stop() {
+        logger.info('Stopping emulator...');
+        if (this.app) {
+            await this.app.close();
+        }
+        return Promise.resolve();
+    }
+}

package/dist/template/response.js

@@ -0,0 +1,8 @@
+export const UNKNOWN_ID_RESPONSE_TEMPLATE = (id) => ({
+    code: -105,
+    message: `Argument 'id', value ${id} not found!`,
+});
+export const ILLEGAL_MODE_RESPONSE_TEMPLATE = (id, mode) => ({
+    code: -106,
+    message: `Emulator for id ${id} is not in ${mode} mode!`,
+});

package/dist/utils/callback-properties.js

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

package/dist/utils/logger.js

@@ -0,0 +1,15 @@
+import pino from 'pino';
+export const logger = pino({
+    transport: {
+        target: 'pino-pretty',
+        options: {
+            colorize: true,
+            translateTime: 'HH:MM:ss',
+            ignore: 'pid,hostname',
+            messageFormat: '{msg}',
+            singleLine: true,
+            hideObject: false,
+        },
+    },
+    level: process.env.V2CA_LOG_LEVEL || 'info',
+});

package/dist/utils/mappers.js

@@ -0,0 +1,18 @@
+export function idToEnergyType(id) {
+    switch (id) {
+        case 0:
+            return 'grid';
+        case 1:
+            return 'solar';
+        default:
+            throw new Error(`Unknown energy type id: ${id}`);
+    }
+}
+export function energyTypeToId(type) {
+    switch (type) {
+        case 'grid':
+            return 0;
+        case 'solar':
+            return 1;
+    }
+}

package/dist/utils/mqtt-callbacks.js

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

package/dist/utils/mqtt.js

@@ -0,0 +1,21 @@
+import mqtt from 'mqtt';
+import { logger } from './logger.js';
+/**
+ * Creates and configures an MQTT client with helpful logging.
+ * Subscribes to lifecycle events (connect, error, reconnect) for visibility.
+ *
+ * @param url - MQTT broker URL (e.g., mqtt://localhost:1883)
+ * @returns A promise that resolves to a connected MqttClient instance
+ * @throws {Error} If the underlying connection fails
+ */
+export async function createMqttClient(url) {
+    const client = await mqtt.connectAsync(url);
+    client.on('connect', () => {
+        logger.info({ url }, 'Connected to MQTT broker');
+    });
+    client.on('error', (err) => {
+        logger.error(err, 'MQTT client error');
+    });
+    client.on('reconnect', () => logger.info('Reconnecting...'));
+    return client;
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "v2c-any",
+  "version": "0.1.2",
+  "type": "module",
+  "description": "V2C device adapter and MQTT publisher (Shelly EM1 compatible)",
+  "main": "dist/index.js",
+  "bin": {
+    "v2ca": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "homepage": "https://github.com/tvcsantos/v2c-any#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tvcsantos/v2c-any.git"
+  },
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "start": "node dist/index.js",
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "eslint src",
+    "lint:fix": "eslint src --fix",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\"",
+    "check": "npm run typecheck && npm run lint && npm run format:check"
+  },
+  "dependencies": {
+    "cosmiconfig": "^9.0.0",
+    "fastify": "^5.0.0",
+    "glob": "^13.0.0",
+    "mqtt": "^5.10.3",
+    "pino-pretty": "^13.1.3",
+    "undici": "^7.1.0",
+    "zod": "^4.2.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.17.0",
+    "@types/node": "^22.10.1",
+    "eslint": "^9.17.0",
+    "eslint-config-prettier": "^9.1.0",
+    "prettier": "^3.4.2",
+    "tsx": "^4.19.2",
+    "typescript": "^5.6.3",
+    "typescript-eslint": "^8.18.2"
+  }
+}