@uns-kit/core 0.0.1

package/dist/tools/schema.d.ts

@@ -0,0 +1,208 @@
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+export type MakeEmpty<T extends {
+    [key: string]: unknown;
+}, K extends keyof T> = {
+    [_ in K]?: never;
+};
+export type Incremental<T> = T | {
+    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+    ID: {
+        input: string;
+        output: string;
+    };
+    String: {
+        input: string;
+        output: string;
+    };
+    Boolean: {
+        input: boolean;
+        output: boolean;
+    };
+    Int: {
+        input: number;
+        output: number;
+    };
+    Float: {
+        input: number;
+        output: number;
+    };
+    Date: {
+        input: any;
+        output: any;
+    };
+};
+export type ActivateMqttTranslation = {
+    enabled?: InputMaybe<Scalars['Boolean']['input']>;
+    sourceTag?: InputMaybe<Scalars['String']['input']>;
+};
+/** MQTT Translator object. */
+export type AddMqttTranslation = {
+    description?: InputMaybe<Scalars['String']['input']>;
+    sourceTag?: InputMaybe<Scalars['String']['input']>;
+    sourceTopic?: InputMaybe<Scalars['String']['input']>;
+    targetTag?: InputMaybe<Scalars['String']['input']>;
+    targetTopic?: InputMaybe<Scalars['String']['input']>;
+    uom?: InputMaybe<Scalars['String']['input']>;
+};
+export type AddMqttTranslatorTopic = {
+    sourceTopic?: InputMaybe<Scalars['String']['input']>;
+};
+export type DeleteMqttTranslation = {
+    sourceTag?: InputMaybe<Scalars['String']['input']>;
+};
+export type DeleteMqttTranslatorTopic = {
+    sourceTopic?: InputMaybe<Scalars['String']['input']>;
+};
+export type InitMqttTranslation = {
+    sourceTag?: InputMaybe<Scalars['String']['input']>;
+    sourceTopic?: InputMaybe<Scalars['String']['input']>;
+};
+export type InsertUnsNode = {
+    parent?: InputMaybe<Scalars['Int']['input']>;
+    unsNode?: InputMaybe<Scalars['String']['input']>;
+};
+export type ModifyMqttTranslation = {
+    description?: InputMaybe<Scalars['String']['input']>;
+    enabled?: InputMaybe<Scalars['Boolean']['input']>;
+    sourceTag?: InputMaybe<Scalars['String']['input']>;
+    targetTag?: InputMaybe<Scalars['String']['input']>;
+    targetTopic?: InputMaybe<Scalars['String']['input']>;
+    uom?: InputMaybe<Scalars['String']['input']>;
+};
+/** MQTT Translator object. */
+export type MqttTranslation = {
+    __typename?: 'MqttTranslation';
+    description?: Maybe<Scalars['String']['output']>;
+    enabled?: Maybe<Scalars['Boolean']['output']>;
+    sourceTag?: Maybe<Scalars['String']['output']>;
+    sourceTopic?: Maybe<Scalars['String']['output']>;
+    targetTag?: Maybe<Scalars['String']['output']>;
+    targetTopic?: Maybe<Scalars['String']['output']>;
+    uom?: Maybe<Scalars['String']['output']>;
+};
+export type MqttTranslatorTopic = {
+    __typename?: 'MqttTranslatorTopic';
+    sourceTopic?: Maybe<Scalars['String']['output']>;
+};
+export type Mutation = {
+    __typename?: 'Mutation';
+    ActivateMqttTranslation?: Maybe<Scalars['Boolean']['output']>;
+    AddMqttTranslation?: Maybe<Scalars['Boolean']['output']>;
+    /** Add MQTT topic to be translated. */
+    AddMqttTranslatorTopic?: Maybe<Scalars['Boolean']['output']>;
+    AddUnsNode?: Maybe<Scalars['Boolean']['output']>;
+    /** Add MQTT translation. */
+    DeleteMqttTranslation?: Maybe<Scalars['Boolean']['output']>;
+    DeleteMqttTranslatorTopic?: Maybe<Scalars['Boolean']['output']>;
+    DeleteRttNode?: Maybe<Scalars['Boolean']['output']>;
+    DeleteUnsNode?: Maybe<Scalars['Boolean']['output']>;
+    DeployRttNode?: Maybe<Scalars['Boolean']['output']>;
+    /** Populate MQTT Translator table with sourceTag and sourceTopic. */
+    InitMqttTranslation?: Maybe<Scalars['Boolean']['output']>;
+    /** Update MQTT Translator table with defined targetTopic. */
+    ModifyMqttTranslation?: Maybe<Scalars['Boolean']['output']>;
+    ModifyUnsNode?: Maybe<Scalars['Boolean']['output']>;
+    StartRttNode?: Maybe<Scalars['Boolean']['output']>;
+    StopRttNode?: Maybe<Scalars['Boolean']['output']>;
+};
+export type MutationActivateMqttTranslationArgs = {
+    entry?: InputMaybe<ActivateMqttTranslation>;
+};
+export type MutationAddMqttTranslationArgs = {
+    entry?: InputMaybe<AddMqttTranslation>;
+};
+export type MutationAddMqttTranslatorTopicArgs = {
+    entry?: InputMaybe<AddMqttTranslatorTopic>;
+};
+export type MutationAddUnsNodeArgs = {
+    node?: InputMaybe<InsertUnsNode>;
+};
+export type MutationDeleteMqttTranslationArgs = {
+    entry?: InputMaybe<DeleteMqttTranslation>;
+};
+export type MutationDeleteMqttTranslatorTopicArgs = {
+    entry?: InputMaybe<DeleteMqttTranslatorTopic>;
+};
+export type MutationDeleteRttNodeArgs = {
+    rttNode?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationDeleteUnsNodeArgs = {
+    id?: InputMaybe<Scalars['Int']['input']>;
+};
+export type MutationDeployRttNodeArgs = {
+    rttNode?: InputMaybe<Scalars['String']['input']>;
+    tag?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationInitMqttTranslationArgs = {
+    entry?: InputMaybe<InitMqttTranslation>;
+};
+export type MutationModifyMqttTranslationArgs = {
+    entry?: InputMaybe<ModifyMqttTranslation>;
+};
+export type MutationModifyUnsNodeArgs = {
+    id?: InputMaybe<Scalars['Int']['input']>;
+    node?: InputMaybe<UpdateUnsNode>;
+};
+export type MutationStartRttNodeArgs = {
+    rttNode?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationStopRttNodeArgs = {
+    rttNode?: InputMaybe<Scalars['String']['input']>;
+};
+/** name: uns-datahub */
+export type Query = {
+    __typename?: 'Query';
+    /** Get MQTT Translator translations. */
+    GetMqttTranslations?: Maybe<Array<Maybe<MqttTranslation>>>;
+    GetMqttTranslatorTopics?: Maybe<Array<Maybe<MqttTranslatorTopic>>>;
+    GetRttNodes?: Maybe<Array<Maybe<RttNode>>>;
+    GetTreeStructure?: Maybe<Array<Maybe<TreeStructure>>>;
+};
+export type RttNode = {
+    __typename?: 'RttNode';
+    author?: Maybe<Scalars['String']['output']>;
+    deployedVersions?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    description?: Maybe<Scalars['String']['output']>;
+    lastLog?: Maybe<Scalars['String']['output']>;
+    latestDeployedVersion?: Maybe<Scalars['String']['output']>;
+    memory?: Maybe<Scalars['Int']['output']>;
+    pid?: Maybe<Scalars['Int']['output']>;
+    restarts?: Maybe<Scalars['Int']['output']>;
+    rttNode?: Maybe<Scalars['String']['output']>;
+    runningVersion?: Maybe<Scalars['String']['output']>;
+    status?: Maybe<Scalars['String']['output']>;
+    uptime?: Maybe<Scalars['Int']['output']>;
+    version?: Maybe<Scalars['String']['output']>;
+};
+export type TreeStructure = {
+    __typename?: 'TreeStructure';
+    children?: Maybe<Array<Maybe<TreeStructure>>>;
+    id?: Maybe<Scalars['Int']['output']>;
+    parent?: Maybe<Scalars['Int']['output']>;
+    unsNode?: Maybe<Scalars['String']['output']>;
+};
+export type UnsNode = {
+    __typename?: 'UnsNode';
+    id?: Maybe<Scalars['Int']['output']>;
+    parent?: Maybe<Scalars['Int']['output']>;
+    unsNode?: Maybe<Scalars['String']['output']>;
+};
+export type UpdateUnsNode = {
+    parent?: InputMaybe<Scalars['Int']['input']>;
+    unsNode?: InputMaybe<Scalars['String']['input']>;
+};

package/dist/tools/schema.js

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

package/dist/tools/update-rtt.d.ts

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

package/dist/tools/update-rtt.js

@@ -0,0 +1,169 @@
+import { basePath } from "./base-path.js";
+import readline from "node:readline";
+import * as path from "path";
+import chalk from "chalk";
+import { readFile } from "fs/promises";
+import fs from "fs-extra";
+import * as prettier from "prettier";
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+});
+const packageJsonPath = path.join(basePath, "package.json");
+const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+// Flags
+const argv = new Set(process.argv.slice(2));
+const DRY_RUN = argv.has("--dry-run") || process.env.DRY_RUN === "1";
+function logAction(action) {
+    if (DRY_RUN)
+        console.log(`[dry-run] ${action}`);
+    else
+        console.log(action);
+}
+function writeJson(file, obj) {
+    return prettier.format(JSON.stringify(obj), { parser: "json" }).then((s) => {
+        if (DRY_RUN) {
+            console.log(`[dry-run] write ${file} (${s.length} bytes)`);
+        }
+        else {
+            fs.writeFileSync(file, s, "utf8");
+        }
+    });
+}
+function copyDir(src, dest, options) {
+    if (DRY_RUN) {
+        console.log(`[dry-run] copy ${src} -> ${dest}`);
+        return;
+    }
+    fs.copySync(src, dest, { overwrite: true, ...options });
+}
+function removePath(p, opts) {
+    if (DRY_RUN) {
+        console.log(`[dry-run] rm ${p}`);
+        return;
+    }
+    fs.rmSync(p, { force: true, recursive: true, ...opts });
+}
+try {
+    await main();
+    rl.close();
+}
+catch (error) {
+    console.log(chalk.red.bold(`\n${error}`));
+    rl.close();
+}
+async function main() {
+    const tmpRtt = path.join(basePath, "/tmp-rtt");
+    try {
+        logAction(`Overwrite examples`);
+        copyDir(path.join(tmpRtt, "/src/examples"), path.join(basePath, "/src/examples"));
+        logAction(`Overwrite uns`);
+        copyDir(path.join(tmpRtt, "/src/uns"), path.join(basePath, "/src/uns"));
+        logAction(`Overwrite uns-config`);
+        copyDir(path.join(tmpRtt, "/src/uns-config"), path.join(basePath, "/src/uns-config"));
+        // Python: copy template but preserve local project area(s) and environments
+        // Preserved by default: python/rtt, python/venv, python/.venv, python/__pycache__
+        const pythonSrc = path.join(tmpRtt, "/python");
+        const pythonDst = path.join(basePath, "/python");
+        logAction(`Overwrite python (preserve local, rtt, venv/.venv, __pycache__)`);
+        copyDir(pythonSrc, pythonDst, {
+            filter: (src) => {
+                // Only filter relative to template python root
+                const rel = path.relative(pythonSrc, src);
+                if (!rel || rel === "")
+                    return true;
+                const top = rel.split(path.sep)[0];
+                const preserved = new Set(["local", "rtt", "venv", ".venv", "__pycache__"]);
+                return !preserved.has(top);
+            },
+        });
+        logAction(`Overwrite uns-grpc`);
+        copyDir(path.join(tmpRtt, "/src/uns-grpc"), path.join(basePath, "/packages/uns-core/src/uns-grpc"));
+        logAction(`Overwrite uns-cron`);
+        copyDir(path.join(tmpRtt, "/src/uns-cron"), path.join(basePath, "/packages/uns-cron/src"));
+        logAction(`Overwrite uns-api`);
+        copyDir(path.join(tmpRtt, "/src/uns-api"), path.join(basePath, "/packages/uns-api/src"));
+        logAction(`Overwrite uns-mqtt`);
+        copyDir(path.join(tmpRtt, "/src/uns-mqtt"), path.join(basePath, "/packages/uns-core/src/uns-mqtt"));
+        logAction(`Overwrite uns-temporal`);
+        copyDir(path.join(tmpRtt, "/src/uns-temporal"), path.join(basePath, "/packages/uns-temporal/src"));
+        logAction(`Overwrite eslint.config.mjs`);
+        copyDir(path.join(tmpRtt, "/eslint.config.mjs"), path.join(basePath, "/eslint.config.mjs"));
+        logAction(`Overwrite schema.ts`);
+        copyDir(path.join(tmpRtt, "/src/graphql/schema.ts"), path.join(basePath, "/src/graphql/schema.ts"));
+        logAction(`Overwrite config-template.json`);
+        copyDir(path.join(tmpRtt, "/config-template.json"), path.join(basePath, "/config-template.json"));
+        logAction(`Overwrite vite.config.js`);
+        copyDir(path.join(tmpRtt, "/vite.config.js"), path.join(basePath, "/vite.config.js"));
+        logAction(`Overwrite codegen.ts`);
+        copyDir(path.join(tmpRtt, "/codegen.ts"), path.join(basePath, "/codegen.ts"));
+        logAction(`Overwrite logger.ts`);
+        copyDir(path.join(tmpRtt, "/src/logger.ts"), path.join(basePath, "/src/logger.ts"));
+    }
+    catch (error) {
+        console.error(chalk.red.bold(`exec error: ${error}`));
+        return;
+    }
+    try {
+        logAction(`Merge package.json scripts (template overrides existing keys, preserves extras)`);
+        const tmpPackageJson = JSON.parse(await readFile(path.join(tmpRtt, 'package.json'), "utf8"));
+        const currentScripts = packageJson.scripts || {};
+        const templateScripts = tmpPackageJson.scripts || {};
+        packageJson.scripts = { ...currentScripts, ...templateScripts };
+        await writeJson('package.json', packageJson);
+    }
+    catch (error) {
+        console.error(chalk.red.bold(`exec error: ${error}`));
+        return;
+    }
+    try {
+        console.log(chalk.red(`Update devDependencies: overwrite versions for existing, add missing; preserve extras.`));
+        const tmpPackageJson = JSON.parse(await readFile(path.join(tmpRtt, 'package.json'), "utf8"));
+        packageJson.devDependencies = packageJson.devDependencies || {};
+        for (const [dep, version] of Object.entries(tmpPackageJson.devDependencies || {})) {
+            packageJson.devDependencies[dep] = version;
+        }
+        await writeJson('package.json', packageJson);
+    }
+    catch (error) {
+        console.error(chalk.red.bold(`exec error: ${error}`));
+        return;
+    }
+    try {
+        console.log(chalk.red(`Update dependencies: keep existing versions; add missing from template.`));
+        const tmpPackageJson = JSON.parse(await readFile(path.join(tmpRtt, 'package.json'), "utf8"));
+        packageJson.dependencies = packageJson.dependencies || {};
+        for (const [dep, version] of Object.entries(tmpPackageJson.dependencies || {})) {
+            if (!(dep in packageJson.dependencies)) {
+                packageJson.dependencies[dep] = version;
+            }
+        }
+        await writeJson('package.json', packageJson);
+    }
+    catch (error) {
+        console.error(chalk.red.bold(`exec error: ${error}`));
+        return;
+    }
+    try {
+        logAction(`Remove obsolete directories and files`);
+        removePath(path.join(basePath, "/src/mqtt-rtt"));
+        removePath(path.join(basePath, "/src/uns-rtt"));
+        removePath(path.join(basePath, "/.eslintignore"));
+        removePath(path.join(basePath, "/.eslintrc.json"));
+        removePath(path.join(basePath, "/src/update-rtt.ts"));
+        removePath(path.join(basePath, "/src/demo"));
+    }
+    catch (error) {
+        console.error(chalk.red.bold(`exec error: ${error}`));
+        return;
+    }
+    try {
+        logAction(`Remove tmp-rtt`);
+        removePath(tmpRtt);
+    }
+    catch (error) {
+        console.error(chalk.red.bold(`exec error: ${error}`));
+        return;
+    }
+    console.log(chalk.green.bold("\nRun npm run build to rebuild the project, and remove obsolete directories and files."));
+}

package/dist/tools/update-tools.d.ts

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

package/dist/tools/update-tools.js

@@ -0,0 +1,72 @@
+import { CleanOptions, simpleGit } from "simple-git";
+import { basePath } from "./base-path.js";
+import readline from "node:readline";
+import * as path from "path";
+import chalk from "chalk";
+import fs from "fs-extra";
+import { execSync } from "child_process";
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+});
+const git = simpleGit("./").clean(CleanOptions.FORCE);
+try {
+    await main();
+    rl.close();
+}
+catch (error) {
+    console.log(chalk.red.bold(`\n${error}`));
+    rl.close();
+}
+async function main() {
+    const tmpRtt = path.join(basePath, "/tmp-rtt");
+    try {
+        console.log(`Pull template-ts-nodejs into tmp-rtt`);
+        await git.clone("git@ssh.dev.azure.com:v3/sijit/industry40/template-uns-rtt", tmpRtt);
+    }
+    catch (error) {
+        console.error(chalk.red.bold(`exec error: ${error}`));
+        return;
+    }
+    try {
+        console.log(`Overwrite tools`);
+        fs.copySync(path.join(tmpRtt, "/src/tools"), path.join(basePath, "/src/tools"), { overwrite: true });
+    }
+    catch (error) {
+        console.error(chalk.red.bold(`exec error: ${error}`));
+        return;
+    }
+    // Update library version JSON at repo root from template
+    try {
+        const srcJson = path.join(tmpRtt, 'uns-library.json');
+        const dstJson = path.join(basePath, 'uns-library.json');
+        if (fs.existsSync(srcJson)) {
+            fs.copyFileSync(srcJson, dstJson);
+            const ver = JSON.parse(fs.readFileSync(srcJson, 'utf8')).version;
+            console.log(`Updated uns-library.json -> ${ver}`);
+        }
+        else {
+            // Fallback for older templates: synthesize from package.json
+            const tmpPackageJsonPath = path.join(tmpRtt, 'package.json');
+            const tmpPackageJson = JSON.parse(fs.readFileSync(tmpPackageJsonPath, 'utf8'));
+            const payload = JSON.stringify({ name: tmpPackageJson.name, version: tmpPackageJson.version }, null, 2);
+            fs.writeFileSync(dstJson, payload + "\n", 'utf8');
+            console.log(`Updated uns-library.json -> ${tmpPackageJson.version}`);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red.bold(`exec error: ${error}`));
+        return;
+    }
+    try {
+        console.log(`Running update-rtt from tools`);
+        // Propagate any CLI args to update-rtt (e.g., --dry-run)
+        const args = process.argv.slice(2).join(" ");
+        // Run the TypeScript tool directly to avoid relying on a successful build
+        execSync(`tsx ./src/tools/update-rtt.ts ${args}`.trim(), { stdio: 'inherit' });
+    }
+    catch (error) {
+        console.error(chalk.red.bold(`exec error: ${error}`));
+        return;
+    }
+}

package/dist/uns/handover-manager-event-emitter.d.ts

@@ -0,0 +1,6 @@
+export declare class HandoverManagerEventEmitter<Events extends Record<string, any>> {
+    private listeners;
+    on<K extends keyof Events>(eventName: K, listener: (event: Events[K]) => void): void;
+    off<K extends keyof Events>(eventName: K, listener: (event: Events[K]) => void): void;
+    emit<K extends keyof Events>(eventName: K, event: Events[K]): void;
+}

package/dist/uns/handover-manager-event-emitter.js

@@ -0,0 +1,19 @@
+export class HandoverManagerEventEmitter {
+    listeners = {};
+    on(eventName, listener) {
+        if (!this.listeners[eventName]) {
+            this.listeners[eventName] = [];
+        }
+        this.listeners[eventName].push(listener);
+    }
+    off(eventName, listener) {
+        if (!this.listeners[eventName])
+            return;
+        this.listeners[eventName] = this.listeners[eventName].filter((l) => l !== listener);
+    }
+    emit(eventName, event) {
+        if (!this.listeners[eventName])
+            return;
+        this.listeners[eventName].forEach((listener) => listener(event));
+    }
+}

package/dist/uns/handover-manager.d.ts

@@ -0,0 +1,34 @@
+import { UnsEvents } from "./uns-interfaces.js";
+import { HandoverManagerEventEmitter } from "./handover-manager-event-emitter.js";
+import { HandoverManagerEvents } from "../uns-mqtt/mqtt-interfaces.js";
+import MqttProxy from "../uns-mqtt/mqtt-proxy.js";
+import UnsMqttProxy from "../uns-mqtt/uns-mqtt-proxy.js";
+/**
+ * HandoverManager is responsible for all handover-related logic,
+ * including handling incoming MQTT messages, issuing handover requests,
+ * and processing handover responses.
+ */
+export declare class HandoverManager {
+    event: HandoverManagerEventEmitter<HandoverManagerEvents>;
+    private processName;
+    private mqttProxy;
+    private unsMqttProxies;
+    private requestingHandover;
+    private handoverInProgress;
+    private topicBuilder;
+    private activeTimeout;
+    private active;
+    handoverRequestEnabled: boolean;
+    handoverEnabled: boolean;
+    forceStartEnabled: boolean;
+    constructor(processName: string, mqttProxy: MqttProxy, unsMqttProxies: UnsMqttProxy[], handoverRequestEnabled: boolean, handoverEnabled: boolean, forceStartEnabled: boolean);
+    /**
+     * Main entry point for handling incoming MQTT messages.
+     * It checks the topic and delegates to the corresponding handler.
+     */
+    handleMqttMessage(event: UnsEvents["input"]): Promise<void>;
+    /**
+     * Handles handovers.
+     */
+    private handleHandover;
+}