@uns-kit/core 0.0.1

package/dist/uns/uns-proxy-process.js

@@ -0,0 +1,179 @@
+import logger from "../logger.js";
+import MqttProxy from "../uns-mqtt/mqtt-proxy.js";
+import UnsMqttProxy from "../uns-mqtt/uns-mqtt-proxy.js";
+import { HandoverManager } from "./handover-manager.js";
+// Import configuration and initialization modules.
+import { PACKAGE_INFO, MQTT_UPDATE_INTERVAL } from "./process-config.js";
+import { getProcessName } from "./process-name-service.js";
+import { MqttTopicBuilder } from "../uns-mqtt/mqtt-topic-builder.js";
+import { StatusMonitor } from "./status-monitor.js";
+import { UnsPacket } from "./uns-packet.js";
+class UnsProxyProcess {
+    active = false;
+    processStatusTopic;
+    processName;
+    unsMqttProxies;
+    unsApiProxies;
+    unsTemporalProxies;
+    processMqttProxy;
+    handoverManager;
+    statusMonitor;
+    // Plugin
+    static pluginApiVersion = 1;
+    static registered = new Set();
+    static registeredMethodNames = new Set();
+    static applied = false;
+    static use(plugin) {
+        if (this.registered.has(plugin))
+            return this;
+        this.registered.add(plugin);
+        if (this.applied)
+            this.applyPlugin(plugin);
+        return this;
+    }
+    static applyPlugin(plugin) {
+        const define = (methods) => {
+            for (const [name, fn] of Object.entries(methods)) {
+                if (typeof fn !== "function") {
+                    throw new TypeError(`UnsProxyProcess plugin attempted to register non-function member \"${name}\".`);
+                }
+                if (this.registeredMethodNames.has(name) || Reflect.has(this.prototype, name)) {
+                    throw new Error(`UnsProxyProcess plugin attempted to overwrite existing member \"${name}\".`);
+                }
+                Object.defineProperty(this.prototype, name, {
+                    value: fn,
+                    writable: true,
+                    configurable: true,
+                    enumerable: false,
+                });
+                this.registeredMethodNames.add(name);
+            }
+        };
+        plugin({
+            define,
+            version: this.pluginApiVersion,
+            UnsProxyProcess: this,
+        });
+    }
+    static applyAll() {
+        if (this.applied)
+            return;
+        this.applied = true;
+        for (const p of this.registered)
+            this.applyPlugin(p);
+    }
+    // References for cleanup.
+    mqttInputHandler;
+    constructor(mqttHost, unsProxyProcessParameters) {
+        this.constructor.applyAll(); // Activate all the plugins
+        this.unsMqttProxies = [];
+        this.unsApiProxies = [];
+        this.unsTemporalProxies = [];
+        this.processName = unsProxyProcessParameters.processName || getProcessName();
+        const { name: packageName, version } = PACKAGE_INFO;
+        // Instantiate the topic builder.
+        const topicBuilder = new MqttTopicBuilder(`uns-infra/${packageName}/${version}/${this.processName}/`);
+        // Generate topics.
+        const processStatusTopic = topicBuilder.getProcessStatusTopic();
+        const handoverTopic = topicBuilder.getHandoverTopic();
+        const wildcardActiveTopic = topicBuilder.getWildcardActiveTopic();
+        this.processStatusTopic = processStatusTopic;
+        // Configure MQTT topics for subscription.
+        const mqttSubToTopics = unsProxyProcessParameters?.mqttSubToTopics ?? [
+            wildcardActiveTopic,
+            handoverTopic,
+        ];
+        const mqttParameters = {
+            mqttSubToTopics,
+            username: unsProxyProcessParameters?.username ?? "",
+            password: unsProxyProcessParameters?.password ?? "",
+            mqttSSL: unsProxyProcessParameters?.mqttSSL ?? false,
+            statusTopic: this.processStatusTopic,
+        };
+        // Initialize MQTT proxy and start connection.
+        this.processMqttProxy = new MqttProxy(mqttHost, this.processName, mqttParameters);
+        this.processMqttProxy.start();
+        // Instantiate and start the StatusMonitor for memory and status updates.
+        this.statusMonitor = new StatusMonitor(this.processMqttProxy, this.processStatusTopic, () => this.active, MQTT_UPDATE_INTERVAL, MQTT_UPDATE_INTERVAL);
+        this.statusMonitor.start();
+    }
+    /**
+     * 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.
+     */
+    initHandoverManager(instanceMode, handover) {
+        const handoverRequestEnabled = instanceMode == "handover" ? true : false;
+        const forceStartEnabled = instanceMode == "force" ? true : false;
+        this.handoverManager = new HandoverManager(this.processName, this.processMqttProxy, this.unsMqttProxies, handoverRequestEnabled, handover ?? true, forceStartEnabled);
+        // Listen for handover events.
+        this.handoverManager.event.on("handoverManager", (event) => {
+            this.active = event.active;
+        });
+        // Delegate MQTT events to the HandoverManager.
+        this.mqttInputHandler = async (event) => {
+            await this.handoverManager.handleMqttMessage(event);
+        };
+        this.processMqttProxy.event.on("input", this.mqttInputHandler);
+    }
+    /**
+     * Creates a new UNS proxy instance and stores it for future management.
+     */
+    async createUnsMqttProxy(mqttHost, instanceName, instanceMode, handover, unsParameters) {
+        // Wait until the MQTT connection is established before proceeding.
+        await this.waitForProcessConnection();
+        // Currently handover manager can handle only mqtt events
+        if (!this.handoverManager) {
+            this.initHandoverManager(instanceMode, handover);
+        }
+        const unsMqttProxy = new UnsMqttProxy(mqttHost, this.processName, instanceName, unsParameters);
+        // Listen for UNS proxy producing topics and publish them via MQTT.
+        unsMqttProxy.event.on("unsProxyProducedTopics", (event) => {
+            this.processMqttProxy.publish(event.statusTopic, JSON.stringify(event.producedTopics), {
+                retain: true,
+                properties: { messageExpiryInterval: 120000 },
+            });
+        });
+        // Listen for UNS proxy status events and publish them via MQTT.
+        unsMqttProxy.event.on("mqttProxyStatus", (event) => {
+            const time = UnsPacket.formatToISO8601(new Date());
+            const unsMessage = { data: { time, value: event.value, uom: event.uom } };
+            UnsPacket.unsPacketFromUnsMessage(unsMessage).then((packet) => {
+                this.processMqttProxy.publish(event.statusTopic, JSON.stringify(packet));
+            });
+        });
+        this.unsMqttProxies.push(unsMqttProxy);
+        return unsMqttProxy;
+    }
+    async waitForProcessConnection() {
+        while (!this.processMqttProxy?.isConnected) {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+    }
+    /**
+     * Shuts down the process by clearing intervals, timeouts, and removing
+     * MQTT event listeners, and stopping the StatusMonitor.
+     */
+    shutdown() {
+        logger.info(`${this.processName} - Shutting down UnsProxyProcess...`);
+        try {
+            this.statusMonitor.stop();
+        }
+        catch (e) {
+            logger.error(`${this.processName} - Error stopping StatusMonitor: ${e.message}`);
+        }
+        if (this.mqttInputHandler) {
+            this.processMqttProxy.event.off("input", this.mqttInputHandler);
+        }
+        try {
+            if (typeof this.processMqttProxy.stop === "function") {
+                this.processMqttProxy.stop();
+            }
+        }
+        catch (e) {
+            logger.error(`${this.processName} - Error stopping MQTT proxy: ${e.message}`);
+        }
+        logger.info(`${this.processName} - Shutdown complete.`);
+    }
+}
+export default UnsProxyProcess;
+export { UnsProxyProcess };

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

@@ -0,0 +1,31 @@
+import { IApiObject, ITopicObject, UnsEvents } from "./uns-interfaces";
+import { UnsEventEmitter } from "./uns-event-emitter.js";
+export default class UnsProxy {
+    private publishInterval;
+    event: UnsEventEmitter<UnsEvents>;
+    protected instanceStatusTopic: string;
+    protected instanceNameWithSuffix: string;
+    private producedTopics;
+    private producedApiEndpoints;
+    constructor();
+    /**
+     * Publishes the list of produced topics to the MQTT broker.
+     */
+    private emitProducedTopics;
+    /**
+     * Publishes the list of produced API endpoints to the MQTT broker.
+     */
+    private emitProducedApiEndpoints;
+    /**
+     * Registers a unique topic so that it is tracked and published only once.
+     *
+     * @param topicObject - The object containing topic details.
+     */
+    protected registerUniqueTopic(topicObject: ITopicObject): void;
+    /**
+     * Registers an API endpoint to handle requests for a specific topic and attribute.
+     */
+    protected registerApiEndpoint(apiObject: IApiObject): void;
+    protected unregisterApiEndpoint(topic: string, attribute: string): void;
+    stop(): Promise<void>;
+}

package/dist/uns/uns-proxy.js

@@ -0,0 +1,120 @@
+import logger from "../logger.js";
+import { UnsEventEmitter } from "./uns-event-emitter.js";
+import { UnsPacket } from "./uns-packet.js";
+export default class UnsProxy {
+    publishInterval = null;
+    event = new UnsEventEmitter();
+    instanceStatusTopic;
+    instanceNameWithSuffix; //was prot
+    producedTopics = new Map();
+    producedApiEndpoints = new Map();
+    constructor() {
+        // Set up interval to publish produced topics every 60 seconds.
+        this.publishInterval = setInterval(() => {
+            this.emitProducedTopics();
+            this.emitProducedApiEndpoints();
+        }, 60000);
+    }
+    /**
+     * Publishes the list of produced topics to the MQTT broker.
+     */
+    async emitProducedTopics() {
+        if (this.instanceStatusTopic !== "") {
+            const topicsArray = [...this.producedTopics.values()];
+            if (topicsArray.length > 0) {
+                try {
+                    if (topicsArray.length > 0) {
+                        this.event.emit("unsProxyProducedTopics", { producedTopics: topicsArray, statusTopic: this.instanceStatusTopic + "topics" });
+                    }
+                }
+                catch (error) {
+                    logger.error(`${this.instanceNameWithSuffix} - Error publishing produced topics: ${error.message}`);
+                }
+                logger.debug(`${this.instanceNameWithSuffix} - Published produced topics.`);
+            }
+        }
+    }
+    /**
+     * Publishes the list of produced API endpoints to the MQTT broker.
+     */
+    async emitProducedApiEndpoints() {
+        if (this.instanceStatusTopic !== "") {
+            const apiEndpointsArray = [...this.producedApiEndpoints.values()];
+            if (apiEndpointsArray.length > 0) {
+                try {
+                    if (apiEndpointsArray.length > 0) {
+                        this.event.emit("unsProxyProducedApiEndpoints", { producedApiEndpoints: apiEndpointsArray, statusTopic: this.instanceStatusTopic + "api-endpoints" });
+                    }
+                }
+                catch (error) {
+                    logger.error(`${this.instanceNameWithSuffix} - Error publishing produced API endpoints: ${error.message}`);
+                }
+                logger.debug(`${this.instanceNameWithSuffix} - Published produced API endpoints.`);
+            }
+        }
+    }
+    /**
+     * Registers a unique topic so that it is tracked and published only once.
+     *
+     * @param topicObject - The object containing topic details.
+     */
+    registerUniqueTopic(topicObject) {
+        if (this.instanceStatusTopic !== "") {
+            const fullTopic = `${topicObject.topic}${topicObject.attribute}`;
+            if (!this.producedTopics.has(fullTopic)) {
+                this.producedTopics.set(fullTopic, {
+                    timestamp: topicObject.timestamp,
+                    topic: topicObject.topic,
+                    attribute: topicObject.attribute,
+                    attributeType: topicObject.attributeType,
+                    description: topicObject.description,
+                    tags: topicObject.tags,
+                    attributeNeedsPersistence: topicObject.attributeNeedsPersistence ?? true,
+                    dataGroup: topicObject.dataGroup ?? ""
+                });
+                this.emitProducedTopics();
+                logger.info(`${this.instanceNameWithSuffix} - Registered new topic: ${fullTopic}`);
+            }
+        }
+    }
+    /**
+     * Registers an API endpoint to handle requests for a specific topic and attribute.
+     */
+    registerApiEndpoint(apiObject) {
+        if (this.instanceStatusTopic !== "") {
+            const fullTopic = `${apiObject.topic}${apiObject.attribute}`;
+            if (!this.producedApiEndpoints.has(fullTopic)) {
+                const time = UnsPacket.formatToISO8601(new Date());
+                this.producedApiEndpoints.set(fullTopic, {
+                    timestamp: time,
+                    topic: apiObject.topic,
+                    attribute: apiObject.attribute,
+                    apiHost: apiObject.apiHost,
+                    apiEndpoint: apiObject.apiEndpoint,
+                    apiMethod: apiObject.apiMethod,
+                    apiQueryParams: apiObject.apiQueryParams,
+                    apiDescription: apiObject.apiDescription,
+                    attributeType: apiObject.attributeType,
+                    apiSwaggerEndpoint: apiObject.apiSwaggerEndpoint
+                });
+                this.emitProducedApiEndpoints();
+                logger.info(`${this.instanceNameWithSuffix} - Registered new api endpoint: /${fullTopic}`);
+            }
+        }
+    }
+    unregisterApiEndpoint(topic, attribute) {
+        const fullTopic = `${topic}${attribute}`;
+        if (this.producedApiEndpoints.has(fullTopic)) {
+            this.producedApiEndpoints.delete(fullTopic);
+            this.emitProducedApiEndpoints();
+            logger.info(`${this.instanceNameWithSuffix} - Unregistered API endpoint: ${fullTopic}`);
+        }
+    }
+    async stop() {
+        // Clear the publishing interval.
+        if (this.publishInterval) {
+            clearInterval(this.publishInterval);
+            this.publishInterval = null;
+        }
+    }
+}

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

@@ -0,0 +1 @@
+export type UnsTags = "" | (string & {});

package/dist/uns/uns-tags.js

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

package/dist/uns/uns-topic-matcher.d.ts

@@ -0,0 +1,9 @@
+export declare class UnsTopicMatcher {
+    /**
+     * Matches a topic with a topic filter, using MQTT rules.
+     * @param topicFilter The MQTT topic filter (may contain `#` or `+` wildcards).
+     * @param topic The topic to test against the filter.
+     * @returns `true` if the topic matches the filter, `false` otherwise.
+     */
+    static matches(topicFilter: string, topic: string): boolean;
+}

package/dist/uns/uns-topic-matcher.js

@@ -0,0 +1,34 @@
+export class UnsTopicMatcher {
+    /**
+     * Matches a topic with a topic filter, using MQTT rules.
+     * @param topicFilter The MQTT topic filter (may contain `#` or `+` wildcards).
+     * @param topic The topic to test against the filter.
+     * @returns `true` if the topic matches the filter, `false` otherwise.
+     */
+    static matches(topicFilter, topic) {
+        // Normalize leading/trailing slashes and collapse empties
+        const filterSegments = topicFilter.split('/').filter(Boolean);
+        const topicSegments = topic.split('/').filter(Boolean);
+        for (let i = 0; i < filterSegments.length; i++) {
+            const filterSegment = filterSegments[i];
+            // Match `#` wildcard
+            if (filterSegment === '#') {
+                return true; // `#` matches everything that follows
+            }
+            // Match `+` wildcard
+            if (filterSegment === '+') {
+                if (topicSegments[i] === undefined) {
+                    return false; // `+` should match exactly one level
+                }
+            }
+            else {
+                // Exact match required
+                if (filterSegment !== topicSegments[i]) {
+                    return false;
+                }
+            }
+        }
+        // Ensure there are no unmatched segments in the topic
+        return filterSegments.length === topicSegments.length;
+    }
+}

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

@@ -0,0 +1 @@
+export type UnsTopics = "" | (string & {});

package/dist/uns/uns-topics.js

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

package/dist/uns-config/config-schema.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare const baseSchema: z.ZodObject<any, "strict", any, {
+    [x: string]: any;
+}, {
+    [x: string]: any;
+}>;
+export type AppConfigFromZod = z.infer<typeof baseSchema>;

package/dist/uns-config/config-schema.js

@@ -0,0 +1,5 @@
+import { composeConfigSchema } from "./schema-tools.js";
+import { unsCoreSchema } from "./uns-core-schema.js";
+import { projectExtrasSchema } from "../config/project.config.extension.js";
+// Plain strict object for generators (no Effects, no dynamic imports)
+export const baseSchema = composeConfigSchema(unsCoreSchema, projectExtrasSchema).strict();

package/dist/uns-config/host-placeholders.d.ts

@@ -0,0 +1,139 @@
+import { z } from "zod";
+declare const inlineHostSchema: z.ZodObject<{
+    provider: z.ZodLiteral<"inline">;
+    value: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    provider?: "inline";
+    value?: string;
+}, {
+    provider?: "inline";
+    value?: string;
+}>;
+declare const externalHostSchema: z.ZodObject<{
+    provider: z.ZodLiteral<"external">;
+    key: z.ZodString;
+    optional: z.ZodOptional<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    provider?: "external";
+    key?: string;
+    optional?: boolean;
+    default?: string;
+}, {
+    provider?: "external";
+    key?: string;
+    optional?: boolean;
+    default?: string;
+}>;
+declare const systemHostSchema: z.ZodObject<{
+    provider: z.ZodLiteral<"system">;
+    family: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"IPv4">, z.ZodLiteral<"IPv6">]>>;
+    interfaceName: z.ZodOptional<z.ZodString>;
+    optional: z.ZodOptional<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    provider?: "system";
+    optional?: boolean;
+    default?: string;
+    family?: "IPv4" | "IPv6";
+    interfaceName?: string;
+}, {
+    provider?: "system";
+    optional?: boolean;
+    default?: string;
+    family?: "IPv4" | "IPv6";
+    interfaceName?: string;
+}>;
+export declare const hostPlaceholderSchema: z.ZodDiscriminatedUnion<"provider", [z.ZodObject<{
+    provider: z.ZodLiteral<"inline">;
+    value: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    provider?: "inline";
+    value?: string;
+}, {
+    provider?: "inline";
+    value?: string;
+}>, z.ZodObject<{
+    provider: z.ZodLiteral<"external">;
+    key: z.ZodString;
+    optional: z.ZodOptional<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    provider?: "external";
+    key?: string;
+    optional?: boolean;
+    default?: string;
+}, {
+    provider?: "external";
+    key?: string;
+    optional?: boolean;
+    default?: string;
+}>, z.ZodObject<{
+    provider: z.ZodLiteral<"system">;
+    family: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"IPv4">, z.ZodLiteral<"IPv6">]>>;
+    interfaceName: z.ZodOptional<z.ZodString>;
+    optional: z.ZodOptional<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    provider?: "system";
+    optional?: boolean;
+    default?: string;
+    family?: "IPv4" | "IPv6";
+    interfaceName?: string;
+}, {
+    provider?: "system";
+    optional?: boolean;
+    default?: string;
+    family?: "IPv4" | "IPv6";
+    interfaceName?: string;
+}>]>;
+export declare const hostValueSchema: z.ZodUnion<[z.ZodString, z.ZodDiscriminatedUnion<"provider", [z.ZodObject<{
+    provider: z.ZodLiteral<"inline">;
+    value: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    provider?: "inline";
+    value?: string;
+}, {
+    provider?: "inline";
+    value?: string;
+}>, z.ZodObject<{
+    provider: z.ZodLiteral<"external">;
+    key: z.ZodString;
+    optional: z.ZodOptional<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    provider?: "external";
+    key?: string;
+    optional?: boolean;
+    default?: string;
+}, {
+    provider?: "external";
+    key?: string;
+    optional?: boolean;
+    default?: string;
+}>, z.ZodObject<{
+    provider: z.ZodLiteral<"system">;
+    family: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"IPv4">, z.ZodLiteral<"IPv6">]>>;
+    interfaceName: z.ZodOptional<z.ZodString>;
+    optional: z.ZodOptional<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    provider?: "system";
+    optional?: boolean;
+    default?: string;
+    family?: "IPv4" | "IPv6";
+    interfaceName?: string;
+}, {
+    provider?: "system";
+    optional?: boolean;
+    default?: string;
+    family?: "IPv4" | "IPv6";
+    interfaceName?: string;
+}>]>]>;
+export type HostPlaceholder = z.infer<typeof hostPlaceholderSchema>;
+export type HostValue = z.infer<typeof hostValueSchema>;
+export type InlineHostPlaceholder = z.infer<typeof inlineHostSchema>;
+export type ExternalHostPlaceholder = z.infer<typeof externalHostSchema>;
+export type SystemHostPlaceholder = z.infer<typeof systemHostSchema>;
+export declare function isHostPlaceholder(value: unknown): value is HostPlaceholder;
+export {};

package/dist/uns-config/host-placeholders.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+// Host placeholders allow configuration values such as MQTT brokers or database
+// hosts to be defined dynamically. They support in-line values as well as
+// externally resolved entries so projects can avoid storing environment-specific
+// hosts directly inside shared config files.
+const inlineHostSchema = z
+    .object({
+    provider: z.literal("inline").describe("Use the supplied host or IP address."),
+    value: z
+        .string()
+        .min(1, "Host/IP value is required")
+        .describe("Host or IP address that should be used directly."),
+})
+    .strict()
+    .describe("Host placeholder resolved from an in-line value.");
+const externalHostSchema = z
+    .object({
+    provider: z.literal("external").describe("Resolve the host from an external mapping."),
+    key: z
+        .string()
+        .min(1, "External host key is required")
+        .describe("Identifier used when resolving the host from HostResolverOptions."),
+    optional: z
+        .boolean()
+        .optional()
+        .describe("Allow the external host to be missing without throwing during resolution."),
+    default: z
+        .string()
+        .optional()
+        .describe("Fallback host when optional is true and the external entry is missing."),
+})
+    .strict()
+    .describe("Host placeholder resolved via HostResolverOptions.externalHosts or resolveExternal function.");
+const systemHostSchema = z
+    .object({
+    provider: z.literal("system").describe("Resolve the host from local network interfaces."),
+    family: z
+        .union([z.literal("IPv4"), z.literal("IPv6")])
+        .default("IPv4")
+        .describe("Address family to return when scanning interfaces."),
+    interfaceName: z
+        .string()
+        .optional()
+        .describe("Specific interface to read (falls back to the first match when omitted)."),
+    optional: z
+        .boolean()
+        .optional()
+        .describe("Allow the interface lookup to fail without throwing during resolution."),
+    default: z
+        .string()
+        .optional()
+        .describe("Fallback host/IP when optional is true and no interface matches."),
+})
+    .strict()
+    .describe("Host placeholder resolved from os.networkInterfaces().");
+export const hostPlaceholderSchema = z.discriminatedUnion("provider", [
+    inlineHostSchema,
+    externalHostSchema,
+    systemHostSchema,
+]);
+export const hostValueSchema = z.union([
+    z
+        .string()
+        .min(1, "Host/IP value is required")
+        .describe("Host or IP address used directly without placeholder."),
+    hostPlaceholderSchema,
+]);
+export function isHostPlaceholder(value) {
+    return hostPlaceholderSchema.safeParse(value).success;
+}

package/dist/uns-config/schema-tolls.d.ts

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export declare function composeConfigSchema<A extends z.AnyZodObject, B extends z.AnyZodObject>(a: A, b: B): z.ZodObject<A["shape"] & B["shape"]>;

package/dist/uns-config/schema-tolls.js

@@ -0,0 +1,4 @@
+// Shallow merge of two ZodObjects into one ZodObject
+export function composeConfigSchema(a, b) {
+    return a.merge(b);
+}

package/dist/uns-config/schema-tools.d.ts

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export declare function composeConfigSchema(core: z.AnyZodObject, ...extras: z.AnyZodObject[]): z.AnyZodObject;

package/dist/uns-config/schema-tools.js

@@ -0,0 +1,18 @@
+// Helper functions in camelCase
+function shapeKeys(obj) {
+    const shape = obj?._def?.shape();
+    return Object.keys(shape ?? {});
+}
+// Function in camelCase is fine
+export function composeConfigSchema(core, ...extras) {
+    const coreKeys = new Set(shapeKeys(core));
+    for (const ext of extras) {
+        const keys = shapeKeys(ext);
+        const overlaps = keys.filter(k => coreKeys.has(k));
+        if (overlaps.length) {
+            throw new Error(`Project extras overlap UNS core keys: ${overlaps.join(", ")}`);
+        }
+        keys.forEach(k => coreKeys.add(k));
+    }
+    return extras.reduce((acc, ext) => acc.merge(ext), core);
+}