@uns-kit/core 0.0.1

package/dist/uns/uns-measurements.d.ts

@@ -0,0 +1,95 @@
+export type MeasurementUnit = PhysicalMeasurements | DataSizeMeasurements | (string & {});
+export declare enum DataSizeMeasurements {
+    Bit = "bit",
+    Byte = "B",
+    KiloByte = "kB",
+    MegaByte = "MB",
+    GigaByte = "GB",
+    TeraByte = "TB",
+    PetaByte = "PB",
+    ExaByte = "EB",
+    ZettaByte = "ZB",
+    YottaByte = "YB"
+}
+export declare enum CounterMeasurements {
+    Kilo = "k",
+    Mega = "M",
+    Giga = "G"
+}
+export declare enum PhysicalMeasurements {
+    None = "",
+    MiliMeter = "mm",
+    Meter = "m",
+    KiloMeter = "km",
+    Feet = "ft",
+    Second = "s",
+    Minute = "min",
+    Hour = "h",
+    Day = "day",
+    Hertz = "Hz",
+    CubicMeter = "m^3",
+    Liter = "l",
+    Gallon = "gal",
+    Psi = "psi",
+    Pascal = "Pa",
+    Bar = "bar",
+    Celsius = "\u00B0C",
+    Fahrenheit = "\u00B0F",
+    Kelvin = "K",
+    Milijoule = "mJ",
+    Joule = "J",
+    Kilojoule = "kJ",
+    Megajoule = "MJ",
+    Gigajoule = "GJ",
+    Terajoule = "TJ",
+    Newton = "N",
+    Bit = "bit",
+    Byte = "byte",
+    B = "B",
+    MilimeterPerSecond = "mm/s",
+    MeterPerSecond = "m/s",
+    MeterPerMinute = "m/min",
+    CentiMeterPerSecond = "cm/s",
+    MeterPerHour = "m/h",
+    KilometerPerHour = "km/h",
+    RevolutionsPerMinute = "rpm",
+    Percent = "percent",
+    PartsPerMillion = "ppm",
+    PartsPerBillion = "ppb",
+    PartsPerTrillion = "ppt",
+    Decibel = "dB",
+    Degree = "\u00B0",
+    Radian = "rad",
+    Miligram = "mg",
+    Gram = "g",
+    Kilogram = "kg",
+    MetricTon = "t",
+    MiliVolt = "mV",
+    Volt = "V",
+    KiloVolt = "kV",
+    MegaVolt = "MV",
+    MiliAmpere = "mA",
+    Ampere = "A",
+    KiloAmpere = "kA",
+    MegaAmpere = "MA",
+    MiliWatt = "mW",
+    Watt = "W",
+    KiloWatt = "kW",
+    MegaWatt = "MW",
+    MiliWattHour = "mWh",
+    WattHour = "Wh",
+    KiloWattHour = "kWh",
+    MegaWattHour = "MWh",
+    MiliVoltAmpere = "mVA",
+    VoltAmpere = "VA",
+    KiloVoltAmpere = "kVA",
+    MegaVoltAmpere = "MVA",
+    MiliVoltAmpereReactive = "mVAR",
+    VoltAmpereReactive = "VAR",
+    KiloVoltAmpereReactive = "kVAR",
+    MegaVoltAmpereReactive = "MVAR",
+    CubicMeterPerHour = "m^3/h",
+    CubicMeterPerSecond = "m^3/s",
+    MegaGramPerHour = "Mg/h",
+    MetricTonPerHour = "t/h"
+}

package/dist/uns/uns-measurements.js

@@ -0,0 +1,146 @@
+// Data Size
+export var DataSizeMeasurements;
+(function (DataSizeMeasurements) {
+    DataSizeMeasurements["Bit"] = "bit";
+    DataSizeMeasurements["Byte"] = "B";
+    DataSizeMeasurements["KiloByte"] = "kB";
+    DataSizeMeasurements["MegaByte"] = "MB";
+    DataSizeMeasurements["GigaByte"] = "GB";
+    DataSizeMeasurements["TeraByte"] = "TB";
+    DataSizeMeasurements["PetaByte"] = "PB";
+    DataSizeMeasurements["ExaByte"] = "EB";
+    DataSizeMeasurements["ZettaByte"] = "ZB";
+    DataSizeMeasurements["YottaByte"] = "YB";
+})(DataSizeMeasurements || (DataSizeMeasurements = {}));
+// Counter Measurements
+export var CounterMeasurements;
+(function (CounterMeasurements) {
+    CounterMeasurements["Kilo"] = "k";
+    CounterMeasurements["Mega"] = "M";
+    CounterMeasurements["Giga"] = "G";
+})(CounterMeasurements || (CounterMeasurements = {}));
+// Physical Measurements
+export var PhysicalMeasurements;
+(function (PhysicalMeasurements) {
+    PhysicalMeasurements["None"] = "";
+    // Length
+    // -------------------------------------------------
+    PhysicalMeasurements["MiliMeter"] = "mm";
+    PhysicalMeasurements["Meter"] = "m";
+    PhysicalMeasurements["KiloMeter"] = "km";
+    PhysicalMeasurements["Feet"] = "ft";
+    // Time
+    // -------------------------------------------------
+    PhysicalMeasurements["Second"] = "s";
+    PhysicalMeasurements["Minute"] = "min";
+    PhysicalMeasurements["Hour"] = "h";
+    PhysicalMeasurements["Day"] = "day";
+    // Frequency
+    // -------------------------------------------------
+    PhysicalMeasurements["Hertz"] = "Hz";
+    // Volume
+    // -------------------------------------------------
+    PhysicalMeasurements["CubicMeter"] = "m^3";
+    PhysicalMeasurements["Liter"] = "l";
+    PhysicalMeasurements["Gallon"] = "gal";
+    // Pressure
+    // -------------------------------------------------
+    PhysicalMeasurements["Psi"] = "psi";
+    PhysicalMeasurements["Pascal"] = "Pa";
+    PhysicalMeasurements["Bar"] = "bar";
+    // Temperature
+    // -------------------------------------------------
+    PhysicalMeasurements["Celsius"] = "\u00B0C";
+    PhysicalMeasurements["Fahrenheit"] = "\u00B0F";
+    PhysicalMeasurements["Kelvin"] = "K";
+    // Energy
+    // -------------------------------------------------
+    PhysicalMeasurements["Milijoule"] = "mJ";
+    PhysicalMeasurements["Joule"] = "J";
+    PhysicalMeasurements["Kilojoule"] = "kJ";
+    PhysicalMeasurements["Megajoule"] = "MJ";
+    PhysicalMeasurements["Gigajoule"] = "GJ";
+    PhysicalMeasurements["Terajoule"] = "TJ";
+    // Force
+    // -------------------------------------------------
+    PhysicalMeasurements["Newton"] = "N";
+    // Data
+    // -------------------------------------------------
+    PhysicalMeasurements["Bit"] = "bit";
+    PhysicalMeasurements["Byte"] = "byte";
+    PhysicalMeasurements["B"] = "B";
+    // Speed
+    // -------------------------------------------------
+    PhysicalMeasurements["MilimeterPerSecond"] = "mm/s";
+    PhysicalMeasurements["MeterPerSecond"] = "m/s";
+    PhysicalMeasurements["MeterPerMinute"] = "m/min";
+    PhysicalMeasurements["CentiMeterPerSecond"] = "cm/s";
+    PhysicalMeasurements["MeterPerHour"] = "m/h";
+    PhysicalMeasurements["KilometerPerHour"] = "km/h";
+    // Rotational Speed
+    // -------------------------------------------------
+    PhysicalMeasurements["RevolutionsPerMinute"] = "rpm";
+    // Percentage
+    // -------------------------------------------------
+    PhysicalMeasurements["Percent"] = "percent";
+    // Parts Per
+    // -------------------------------------------------
+    PhysicalMeasurements["PartsPerMillion"] = "ppm";
+    PhysicalMeasurements["PartsPerBillion"] = "ppb";
+    PhysicalMeasurements["PartsPerTrillion"] = "ppt";
+    // Other Angular Units
+    // -------------------------------------------------
+    PhysicalMeasurements["Decibel"] = "dB";
+    PhysicalMeasurements["Degree"] = "\u00B0";
+    PhysicalMeasurements["Radian"] = "rad";
+    // Mass
+    // -------------------------------------------------
+    PhysicalMeasurements["Miligram"] = "mg";
+    PhysicalMeasurements["Gram"] = "g";
+    PhysicalMeasurements["Kilogram"] = "kg";
+    PhysicalMeasurements["MetricTon"] = "t";
+    // Electric Potential
+    // -------------------------------------------------
+    PhysicalMeasurements["MiliVolt"] = "mV";
+    PhysicalMeasurements["Volt"] = "V";
+    PhysicalMeasurements["KiloVolt"] = "kV";
+    PhysicalMeasurements["MegaVolt"] = "MV";
+    // Electric Current
+    // -------------------------------------------------
+    PhysicalMeasurements["MiliAmpere"] = "mA";
+    PhysicalMeasurements["Ampere"] = "A";
+    PhysicalMeasurements["KiloAmpere"] = "kA";
+    PhysicalMeasurements["MegaAmpere"] = "MA";
+    // Power
+    // -------------------------------------------------
+    PhysicalMeasurements["MiliWatt"] = "mW";
+    PhysicalMeasurements["Watt"] = "W";
+    PhysicalMeasurements["KiloWatt"] = "kW";
+    PhysicalMeasurements["MegaWatt"] = "MW";
+    // Energy per unit time
+    // -------------------------------------------------
+    PhysicalMeasurements["MiliWattHour"] = "mWh";
+    PhysicalMeasurements["WattHour"] = "Wh";
+    PhysicalMeasurements["KiloWattHour"] = "kWh";
+    PhysicalMeasurements["MegaWattHour"] = "MWh";
+    // Apparent Power
+    // -------------------------------------------------
+    PhysicalMeasurements["MiliVoltAmpere"] = "mVA";
+    PhysicalMeasurements["VoltAmpere"] = "VA";
+    PhysicalMeasurements["KiloVoltAmpere"] = "kVA";
+    PhysicalMeasurements["MegaVoltAmpere"] = "MVA";
+    // Reactive Power
+    // -------------------------------------------------
+    PhysicalMeasurements["MiliVoltAmpereReactive"] = "mVAR";
+    PhysicalMeasurements["VoltAmpereReactive"] = "VAR";
+    PhysicalMeasurements["KiloVoltAmpereReactive"] = "kVAR";
+    PhysicalMeasurements["MegaVoltAmpereReactive"] = "MVAR";
+    // Flow Rates
+    // -------------------------------------------------
+    PhysicalMeasurements["CubicMeterPerHour"] = "m^3/h";
+    PhysicalMeasurements["CubicMeterPerSecond"] = "m^3/s";
+    // Other
+    // -------------------------------------------------
+    PhysicalMeasurements["MegaGramPerHour"] = "Mg/h";
+    PhysicalMeasurements["MetricTonPerHour"] = "t/h";
+})(PhysicalMeasurements || (PhysicalMeasurements = {}));

package/dist/uns/uns-packet.d.ts

@@ -0,0 +1,28 @@
+import { IUnsPacket, ISO8601, IUnsMessage, IUnsPackatParameters } from "./uns-interfaces.js";
+export declare class UnsPacket {
+    /**
+     * The given TypeScript function parseMqttPacket is used to parse an MQTT packet,
+     * which is presumed to be in JSON format. The goal is to transform this string into
+     * a structured object that adheres to the IUnsPacket interface, or return null
+     * if parsing fails.
+     *
+     * @param mqttPacket
+     * @param instanceName
+     * @returns IUnsPacket
+     */
+    static parseMqttPacket(mqttPacket: string, instanceName?: string): IUnsPacket | null;
+    /**
+     * Validates the data and event objects to ensure they have the required properties
+     * and that those properties have the correct types.
+     *
+     * @param data - The data object to validate
+     * @param event - The event object to validate
+     * @returns boolean | null
+     */
+    private static validateMessageComponents;
+    static unsPacketFromUnsMessage(message: IUnsMessage, unsPackatParameters?: IUnsPackatParameters): Promise<IUnsPacket>;
+    private static generateHmac;
+    static formatToISO8601(date: Date): ISO8601;
+    private static compressString;
+    private static decompressString;
+}

package/dist/uns/uns-packet.js

@@ -0,0 +1,223 @@
+import * as crypto from "crypto";
+import * as zlib from "zlib";
+import logger from '../logger.js';
+import { isIOS8601Type } from "./uns-interfaces.js";
+// Version of the packet library
+const unsPacketVersion = "1.2.0";
+export class UnsPacket {
+    /**
+     * The given TypeScript function parseMqttPacket is used to parse an MQTT packet,
+     * which is presumed to be in JSON format. The goal is to transform this string into
+     * a structured object that adheres to the IUnsPacket interface, or return null
+     * if parsing fails.
+     *
+     * @param mqttPacket
+     * @param instanceName
+     * @returns IUnsPacket
+     */
+    static parseMqttPacket(mqttPacket, instanceName) {
+        try {
+            const parsedMqttPacket = JSON.parse(mqttPacket);
+            // Check uns packet
+            if (parsedMqttPacket && parsedMqttPacket.version) {
+                const version = parsedMqttPacket.version;
+                const command = parsedMqttPacket.message.command;
+                const event = parsedMqttPacket.message.event;
+                const data = parsedMqttPacket.message.data;
+                const table = parsedMqttPacket.message.table;
+                const expiresAt = parsedMqttPacket.message.expiresAt;
+                const createdAt = parsedMqttPacket.message.createdAt;
+                // Validate data and event objects
+                UnsPacket.validateMessageComponents(data, event, table);
+                const message = {
+                    ...(command !== undefined && { command }),
+                    ...(data !== undefined && { data }),
+                    ...(table !== undefined && { table }),
+                    ...(event !== undefined && { event }),
+                    ...(expiresAt !== undefined && { expiresAt }),
+                    ...(createdAt !== undefined && { createdAt }),
+                };
+                const messageSignature = parsedMqttPacket.messageSignature;
+                const interval = parsedMqttPacket.interval;
+                const unsPacket = {
+                    message,
+                    messageSignature,
+                    version,
+                    interval
+                };
+                return unsPacket;
+            }
+            else {
+                logger.debug("Version number not specified in the mqtt packet");
+            }
+        }
+        catch (error) {
+            if (instanceName) {
+                logger.error(`${instanceName} - Could not parse packet: ${error}`);
+            }
+            else {
+                logger.error(`Could not parse packet: ${error}`);
+            }
+        }
+    }
+    /**
+     * Validates the data and event objects to ensure they have the required properties
+     * and that those properties have the correct types.
+     *
+     * @param data - The data object to validate
+     * @param event - The event object to validate
+     * @returns boolean | null
+     */
+    static validateMessageComponents(data, event, table) {
+        if (data) {
+            if (data.dataGroup) {
+                if (!/^[A-Za-z0-9_]+$/.test(data.dataGroup)) {
+                    throw new Error(`dataGroup must be a valid name (alphanumeric and underscores only, no spaces or special characters)`);
+                }
+            }
+            if (!data.time)
+                throw new Error(`Time is not defined in data object`);
+            if (!isIOS8601Type(data.time))
+                throw new Error(`Time is not ISO8601`);
+        }
+        // Check event object
+        if (event) {
+            if (event.dataGroup) {
+                if (!/^[A-Za-z0-9_]+$/.test(event.dataGroup)) {
+                    throw new Error(`dataGroup must be a valid name (alphanumeric and underscores only, no spaces or special characters)`);
+                }
+            }
+            if (!event.time) {
+                throw new Error(`Time is not defined in data object`);
+            }
+            if (!isIOS8601Type(event.time))
+                throw new Error(`Time is not ISO8601`);
+        }
+        // Check table object
+        if (table) {
+            if (table.dataGroup) {
+                if (!/^[A-Za-z0-9_]+$/.test(table.dataGroup)) {
+                    throw new Error(`dataGroup must be a valid name (alphanumeric and underscores only, no spaces or special characters)`);
+                }
+            }
+            if (!table.time) {
+                throw new Error(`Time is not defined in data object`);
+            }
+            if (!isIOS8601Type(table.time)) {
+                throw new Error(`Time is not ISO8601`);
+            }
+            const oldTable = table;
+            if (oldTable.tableName) {
+                logger.debug(`The 'tableName' property is deprecated. Use 'dataGroup' instead.`);
+            }
+            else if (table.values) {
+                Object.entries(table.values).forEach(([key, value]) => {
+                    if (typeof value !== "number" &&
+                        typeof value !== "string" &&
+                        value !== null &&
+                        value !== undefined) {
+                        throw new Error(`Value for key '${key}' in table.values must be of type number, string, null, or undefined`);
+                    }
+                });
+            }
+            else {
+                throw new Error(`No values for table`);
+            }
+        }
+        return true;
+    }
+    static async unsPacketFromUnsMessage(message, unsPackatParameters) {
+        try {
+            // Validate the packet in message
+            if (UnsPacket.validateMessageComponents(message.data, message.event, message.table)) {
+                if (unsPackatParameters) {
+                    // if (
+                    //   unsPackatParameters.compressCommand &&
+                    //   unsPackatParameters.compressCommand == true
+                    // ) {
+                    //   message.command = (
+                    //     await this.compressString(message.command)
+                    //   ).toString();
+                    // }
+                }
+                // HMAC
+                // const algorithm = "sha256";
+                // const key = "your-secret-key";
+                // const packetMessage = JSON.stringify(message);
+                // const hmacHash = this.generateHmac(algorithm, key, packetMessage);
+                // const unsPacket: IUnsPacket = {
+                //   message,
+                //   messageSignature: hmacHash,
+                //   version: unsPacketVersion
+                // };
+                let data = undefined;
+                if (message.data && message.data.value !== undefined) {
+                    data = {
+                        ...message.data,
+                        valueType: typeof message.data.value
+                    };
+                }
+                ;
+                const extendedMessage = {
+                    command: message.command,
+                    data,
+                    table: message.table,
+                    event: message.event,
+                    expiresAt: message.expiresAt,
+                    createdAt: message.createdAt,
+                };
+                const unsPacket = {
+                    message: extendedMessage,
+                    version: unsPacketVersion,
+                };
+                return unsPacket;
+            }
+        }
+        catch (error) {
+            logger.error(`Could not create packet from message: ${error}`);
+        }
+    }
+    static generateHmac(algorithm, key, data) {
+        const hmac = crypto.createHmac(algorithm, key);
+        hmac.update(data);
+        return hmac.digest("hex");
+    }
+    static formatToISO8601(date) {
+        const year = date.getUTCFullYear();
+        const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+        const day = String(date.getUTCDate()).padStart(2, "0");
+        const hours = String(date.getUTCHours()).padStart(2, "0");
+        const minutes = String(date.getUTCMinutes()).padStart(2, "0");
+        const seconds = String(date.getUTCSeconds()).padStart(2, "0");
+        const milliseconds = String(date.getUTCMilliseconds()).padStart(3, "0");
+        return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${milliseconds}Z`;
+    }
+    static compressString(input) {
+        return new Promise((resolve, reject) => {
+            zlib.deflate(input, (err, buffer) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    const base64String = buffer.toString("base64");
+                    resolve(base64String);
+                }
+            });
+        });
+    }
+    // Function to decompress a Buffer back to a string
+    static decompressString(base64Compressed) {
+        return new Promise((resolve, reject) => {
+            // Decode the base64 string to a Buffer
+            const compressedBuffer = Buffer.from(base64Compressed, "base64");
+            zlib.inflate(compressedBuffer, (err, buffer) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(buffer.toString());
+                }
+            });
+        });
+    }
+}

package/dist/uns/uns-proxy-process.d.ts

@@ -0,0 +1,56 @@
+import { IUnsParameters, IUnsProcessParameters } from "./uns-interfaces.js";
+import UnsMqttProxy from "../uns-mqtt/uns-mqtt-proxy.js";
+/**
+ * UnsProxyProcess is responsible for managing the process lifecycle,
+ * configuring MQTT (subscriptions and publishing for status updates), and
+ * handling UNS proxy instances.
+ *
+ * It leverages HandoverManager for handover events and StatusMonitor for health reporting.
+ */
+export type UnsProxyProcessPluginMethod = (this: UnsProxyProcess, ...args: unknown[]) => unknown;
+export type UnsProxyProcessPluginMethods = Record<string, UnsProxyProcessPluginMethod>;
+export interface UnsProxyProcessPluginApi {
+    version: number;
+    define(methods: UnsProxyProcessPluginMethods): void;
+    UnsProxyProcess: typeof UnsProxyProcess;
+}
+export type UnsProxyProcessPlugin = (api: UnsProxyProcessPluginApi) => void;
+declare class UnsProxyProcess {
+    private active;
+    private processStatusTopic;
+    private processName;
+    private unsMqttProxies;
+    private unsApiProxies;
+    private unsTemporalProxies;
+    private processMqttProxy;
+    private handoverManager;
+    private statusMonitor;
+    static pluginApiVersion: number;
+    private static registered;
+    private static registeredMethodNames;
+    private static applied;
+    static use(plugin: UnsProxyProcessPlugin): typeof UnsProxyProcess;
+    private static applyPlugin;
+    private static applyAll;
+    private mqttInputHandler;
+    constructor(mqttHost: string, unsProxyProcessParameters?: IUnsProcessParameters);
+    /**
+     * Initializes the HandoverManager instance and sets up event listeners for handover and MQTT input events.
+     * Determines handover and force start modes based on process arguments.
+     */
+    private initHandoverManager;
+    /**
+     * Creates a new UNS proxy instance and stores it for future management.
+     */
+    createUnsMqttProxy(mqttHost: string, instanceName: string, instanceMode: string, handover: boolean, unsParameters?: IUnsParameters): Promise<UnsMqttProxy>;
+    waitForProcessConnection(): Promise<void>;
+    /**
+     * Shuts down the process by clearing intervals, timeouts, and removing
+     * MQTT event listeners, and stopping the StatusMonitor.
+     */
+    shutdown(): void;
+}
+interface UnsProxyProcess {
+}
+export default UnsProxyProcess;
+export { UnsProxyProcess };