@uns-kit/api 2.0.45 → 2.0.46

package/dist/api-interfaces.d.ts

@@ -1 +1,185 @@
-export type { IApiProxyOptions, IGetEndpointOptions, QueryParamDef } from "@uns-kit/core/uns/uns-interfaces.js";
+export type { IApiProxyOptions, IGetEndpointOptions, IPostEndpointOptions, QueryParamDef, } from "@uns-kit/core/uns/uns-interfaces.js";
+import type { IGetEndpointOptions, IPostEndpointOptions } from "@uns-kit/core/uns/uns-interfaces.js";
+export type ApiInteractionMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+export type DataCatalogParameterRegistration = {
+    name: string;
+    in: "path" | "query" | "header" | "cookie";
+    required?: boolean;
+    description?: string | null;
+    type?: string | null;
+    format?: string | null;
+    nullable?: boolean;
+    example?: unknown;
+    enumValues?: string[];
+    schema?: unknown;
+};
+export type DataCatalogSchemaFieldRegistration = {
+    name: string;
+    path?: string;
+    sourceKey?: string | null;
+    type?: string | null;
+    format?: string | null;
+    nullable?: boolean;
+    required?: boolean;
+    description?: string | null;
+    enumValues?: string[];
+    example?: unknown;
+};
+export type DataCatalogSchemaRegistration = {
+    id: string;
+    title: string;
+    kind?: string | null;
+    source?: string | null;
+    contentType?: string | null;
+    rootType?: string | null;
+    fieldPathPrefix?: string | null;
+    nullable?: boolean;
+    description?: string | null;
+    fields?: DataCatalogSchemaFieldRegistration[];
+    examplePayloads?: unknown[];
+};
+export type DataCatalogRequestBodyRegistration = {
+    required?: boolean;
+    description?: string | null;
+    contentType?: string | null;
+    schemas?: DataCatalogSchemaRegistration[];
+    schemaIds?: string[];
+};
+export type DataCatalogResponseRegistration = {
+    statusCode: string;
+    description?: string | null;
+    contentType?: string | null;
+    schemas?: DataCatalogSchemaRegistration[];
+    schemaIds?: string[];
+    examplePayloads?: unknown[];
+    headers?: DataCatalogParameterRegistration[];
+};
+export type DataCatalogOperationRegistration = {
+    id?: string;
+    method: ApiInteractionMethod | "HEAD" | "OPTIONS";
+    path: string;
+    summary?: string | null;
+    description?: string | null;
+    tags?: string[];
+    deprecated?: boolean;
+    parameters?: DataCatalogParameterRegistration[];
+    headers?: DataCatalogParameterRegistration[];
+    requestBody?: DataCatalogRequestBodyRegistration | null;
+    responses?: DataCatalogResponseRegistration[];
+};
+export type DataCatalogOfferRegistration = {
+    offerId: string;
+    displayName: string;
+    description?: string | null;
+    owner?: string | null;
+    status?: string | null;
+    tags?: string[];
+    categories?: string[];
+    microserviceName?: string | null;
+    version?: string | null;
+    basePaths?: string[];
+    operations: DataCatalogOperationRegistration[];
+    schemas?: DataCatalogSchemaRegistration[];
+    swaggerPath?: string | null;
+    metadata?: Record<string, unknown> | null;
+};
+type ApiRouteIdentity<Handler = unknown> = {
+    topic: string;
+    asset: string;
+    objectType: string;
+    objectId: string;
+    attribute: string;
+    handler: Handler;
+};
+export type DataCatalogOfferSourceRegistration<Handler = unknown> = ApiRouteIdentity<Handler> & {
+    offerId: string;
+    displayName: string;
+    description: string;
+    owner?: string;
+    status?: string;
+    tags?: string[];
+    categories?: string[];
+    method?: ApiInteractionMethod;
+    queryParams?: DataCatalogParameterRegistration[];
+    headers?: DataCatalogParameterRegistration[];
+    requestBody?: DataCatalogRequestBodyRegistration | null;
+    response?: {
+        statusCode?: string;
+        description?: string | null;
+        contentType?: string | null;
+        headers?: DataCatalogParameterRegistration[];
+        examplePayloads?: unknown[];
+    };
+    schema: DataCatalogSchemaRegistration;
+    apiDescription?: string;
+};
+export type ServiceApiRegistration<Handler = unknown> = {
+    attribute: string;
+    handler: Handler;
+    method?: ApiInteractionMethod;
+    description: string;
+    publishInUnsTree?: boolean;
+    tags?: string[];
+    queryParams?: DataCatalogParameterRegistration[];
+    requestBody?: DataCatalogRequestBodyRegistration | null;
+    response?: DataCatalogResponseRegistration;
+    schema?: DataCatalogSchemaRegistration;
+    topic?: string;
+    asset?: string;
+    objectType?: string;
+    objectId?: string;
+};
+export type ApiInteractionDefinition<Handler = unknown> = {
+    id: string;
+    topic: string;
+    asset: string;
+    objectType: string;
+    objectId: string;
+    attribute: string;
+    method: ApiInteractionMethod;
+    routeOnly?: boolean;
+    registryTopic?: "api-endpoints" | "service-endpoints" | "data-offer-endpoints";
+    options: IGetEndpointOptions | IPostEndpointOptions;
+    handler: Handler;
+};
+export declare function defineApiInteraction<Handler>(input: ApiInteractionDefinition<Handler>): ApiInteractionDefinition<Handler>;
+export declare function defineServiceApi<Handler>(input: ServiceApiRegistration<Handler>): ServiceApiRegistration<Handler>;
+export declare function buildApiInteractionPath(route: Pick<ApiInteractionDefinition, "topic" | "asset" | "objectType" | "objectId" | "attribute">, apiBasePrefix?: string): string;
+export declare function buildApiInteractionTopicPath(route: Pick<ApiInteractionDefinition, "topic" | "asset" | "objectType" | "objectId" | "attribute">): string;
+export declare function defineDataCatalogQueryParam(name: string, description: string, options?: {
+    required?: boolean;
+    type?: string;
+    format?: string;
+    example?: unknown;
+}): DataCatalogParameterRegistration;
+export declare function defineDataCatalogField(name: string, type: string, description: string, options?: {
+    path?: string;
+    sourceKey?: string;
+    required?: boolean;
+    format?: string;
+    nullable?: boolean;
+    example?: unknown;
+    enumValues?: string[];
+}): DataCatalogSchemaFieldRegistration;
+export declare function defineDataCatalogSchema(input: {
+    id: string;
+    title: string;
+    contentType: string;
+    description?: string;
+    kind?: string;
+    source?: string;
+    rootType?: string;
+    fieldPathPrefix?: string;
+    fields: DataCatalogSchemaFieldRegistration[];
+    examplePayloads?: unknown[];
+}): DataCatalogSchemaRegistration;
+export declare function buildDataCatalogOfferOperation(route: Pick<ApiInteractionDefinition, "topic" | "asset" | "objectType" | "objectId" | "attribute">, operation: Omit<DataCatalogOperationRegistration, "path">, apiBasePrefix?: string): DataCatalogOperationRegistration;
+export declare function defineDataCatalogOfferSource<Handler>(input: DataCatalogOfferSourceRegistration<Handler>): DataCatalogOfferSourceRegistration<Handler>;
+export declare function buildServiceApiInteractions<Handler, T extends Record<string, ServiceApiRegistration<Handler>>>(processName: string, definitions: T): Record<keyof T, ApiInteractionDefinition<Handler>>;
+export declare function buildApiInteractionsFromDataOfferSources<Handler, T extends Record<string, DataCatalogOfferSourceRegistration<Handler>>>(sources: T): Record<keyof T, ApiInteractionDefinition<Handler>>;
+export declare function buildDataCatalogOffersFromSources<T extends Record<string, DataCatalogOfferSourceRegistration<any>>>(sources: T): DataCatalogOfferRegistration[];
+export declare function projectRowsForDataCatalogSchema(rows: Array<Record<string, unknown>>, schema: DataCatalogSchemaRegistration): Array<Record<string, unknown>>;
+export declare function buildSchemaFieldPathIndex(schema: DataCatalogSchemaRegistration): Array<{
+    path: string;
+    name: string;
+}>;

package/dist/api-interfaces.js

@@ -1 +1,311 @@
-export {};
+import { buildUnsRoutePath } from "@uns-kit/core/uns/uns-path.js";
+export function defineApiInteraction(input) {
+    return input;
+}
+export function defineServiceApi(input) {
+    return input;
+}
+export function buildApiInteractionPath(route, apiBasePrefix = "/api") {
+    return `${apiBasePrefix}${buildUnsRoutePath(route.topic, route.asset, route.objectType, route.objectId, route.attribute)}`.replace(/\/{2,}/g, "/");
+}
+export function buildApiInteractionTopicPath(route) {
+    return buildUnsRoutePath(route.topic, route.asset, route.objectType, route.objectId, route.attribute).slice(1);
+}
+export function defineDataCatalogQueryParam(name, description, options = {}) {
+    return {
+        name,
+        in: "query",
+        type: options.type ?? "string",
+        required: options.required === true,
+        description,
+        ...(options.format ? { format: options.format } : {}),
+        ...(options.example !== undefined ? { example: options.example } : {}),
+    };
+}
+export function defineDataCatalogField(name, type, description, options = {}) {
+    return {
+        name,
+        path: options.path ?? name,
+        type,
+        description,
+        required: options.required === true,
+        nullable: options.nullable === true,
+        ...(options.format ? { format: options.format } : {}),
+        ...(options.example !== undefined ? { example: options.example } : {}),
+        ...(Array.isArray(options.enumValues) ? { enumValues: options.enumValues } : {}),
+        ...(options.sourceKey ? { sourceKey: options.sourceKey } : {}),
+    };
+}
+export function defineDataCatalogSchema(input) {
+    const fieldPathPrefix = input.fieldPathPrefix?.trim();
+    const fields = input.fields.map((field) => ({
+        ...field,
+        path: field.path ?? buildSchemaFieldPath(field.name, field.type ?? "string", fieldPathPrefix),
+    }));
+    const shouldAutogenerateExamples = !isBinaryCatalogContentType(input.contentType);
+    const examplePayloads = Array.isArray(input.examplePayloads) && input.examplePayloads.length
+        ? input.examplePayloads
+        : shouldAutogenerateExamples
+            ? buildExamplePayloadsFromFields(fields)
+            : [];
+    return {
+        id: input.id,
+        title: input.title,
+        kind: input.kind ?? "response",
+        source: input.source ?? "registered",
+        contentType: input.contentType,
+        rootType: input.rootType ?? inferSchemaRootType(input.contentType, input.fields),
+        ...(fieldPathPrefix ? { fieldPathPrefix } : {}),
+        ...(input.description ? { description: input.description } : {}),
+        fields,
+        ...(examplePayloads?.length ? { examplePayloads } : {}),
+    };
+}
+function isBinaryCatalogContentType(contentType) {
+    const normalized = String(contentType ?? "").toLowerCase();
+    return normalized.includes("parquet") || normalized.includes("octet-stream");
+}
+export function buildDataCatalogOfferOperation(route, operation, apiBasePrefix = "/api") {
+    return {
+        ...operation,
+        path: buildApiInteractionPath(route, apiBasePrefix),
+    };
+}
+export function defineDataCatalogOfferSource(input) {
+    return input;
+}
+export function buildServiceApiInteractions(processName, definitions) {
+    return Object.fromEntries(Object.entries(definitions).map(([key, definition]) => [
+        key,
+        defineApiInteraction({
+            id: String(key),
+            topic: definition.topic ?? "system",
+            asset: definition.asset ?? "service",
+            objectType: definition.objectType ?? "runtime",
+            objectId: definition.objectId ?? processName,
+            attribute: definition.attribute,
+            method: definition.method ?? "GET",
+            routeOnly: definition.publishInUnsTree !== true,
+            registryTopic: "service-endpoints",
+            options: buildApiInteractionOptions(definition.method ?? "GET", definition.description, definition.tags, definition.queryParams, definition.requestBody, definition.publishInUnsTree !== true, "service-endpoints", buildServiceApiPayload(String(key), definition)),
+            handler: definition.handler,
+        }),
+    ]));
+}
+export function buildApiInteractionsFromDataOfferSources(sources) {
+    return Object.fromEntries(Object.entries(sources).map(([key, source]) => [
+        key,
+        defineApiInteraction({
+            id: source.offerId,
+            topic: source.topic,
+            asset: source.asset,
+            objectType: source.objectType,
+            objectId: source.objectId,
+            attribute: source.attribute,
+            method: source.method ?? "GET",
+            routeOnly: true,
+            registryTopic: "data-offer-endpoints",
+            options: buildApiInteractionOptions(source.method ?? "GET", source.apiDescription ?? source.description, source.tags, source.queryParams, source.requestBody, true, "data-offer-endpoints"),
+            handler: source.handler,
+        }),
+    ]));
+}
+export function buildDataCatalogOffersFromSources(sources) {
+    return Object.values(sources).map((source) => ({
+        offerId: source.offerId,
+        displayName: source.displayName,
+        description: source.description,
+        ...(source.owner ? { owner: source.owner } : {}),
+        status: source.status ?? "available",
+        ...(source.tags ? { tags: source.tags } : {}),
+        ...(source.categories ? { categories: source.categories } : {}),
+        schemas: [source.schema],
+        operations: [
+            buildDataCatalogOfferOperation(source, {
+                id: `${source.offerId}-${(source.method ?? "GET").toLowerCase()}`,
+                method: source.method ?? "GET",
+                summary: source.displayName,
+                description: source.description,
+                ...(source.tags ? { tags: source.tags } : {}),
+                ...(source.queryParams ? { parameters: source.queryParams } : {}),
+                ...(source.headers ? { headers: source.headers } : {}),
+                ...(source.requestBody !== undefined ? { requestBody: source.requestBody } : {}),
+                responses: [
+                    {
+                        statusCode: source.response?.statusCode ?? "200",
+                        ...(source.response?.description ? { description: source.response.description } : { description: source.description }),
+                        contentType: source.response?.contentType ?? source.schema.contentType ?? null,
+                        schemas: [source.schema],
+                        ...(source.response?.examplePayloads ? { examplePayloads: source.response.examplePayloads } : {}),
+                        ...(source.response?.headers ? { headers: source.response.headers } : { headers: [] }),
+                    },
+                ],
+            }),
+        ],
+    }));
+}
+export function projectRowsForDataCatalogSchema(rows, schema) {
+    const leafFields = (schema.fields ?? []).filter((field) => field.type !== "array");
+    return rows.map((row) => {
+        const projected = {};
+        for (const field of leafFields) {
+            const outputKey = field.name;
+            const sourceKey = field.sourceKey?.trim() || field.name;
+            projected[outputKey] = getRowValue(row, sourceKey);
+        }
+        return projected;
+    });
+}
+export function buildSchemaFieldPathIndex(schema) {
+    return (schema.fields ?? []).map((field) => ({
+        path: field.path ?? field.name,
+        name: field.name,
+    }));
+}
+function inferSchemaRootType(contentType, fields) {
+    if (contentType.includes("parquet") || contentType.includes("octet-stream")) {
+        return "table";
+    }
+    if (fields.some((field) => (field.path ?? field.name).includes("[]"))) {
+        return "object";
+    }
+    return "object";
+}
+function buildSchemaFieldPath(name, type, fieldPathPrefix) {
+    if (fieldPathPrefix && type !== "array") {
+        return `${fieldPathPrefix}.${name}`;
+    }
+    return name;
+}
+function buildApiInteractionOptions(method, description, tags, queryParams, requestBody, routeOnly = true, registryTopic = "api-endpoints", serviceApi) {
+    if (method === "GET") {
+        return {
+            apiDescription: description,
+            ...(routeOnly ? { routeOnly: true } : {}),
+            ...(registryTopic ? { registryTopic } : {}),
+            ...(serviceApi ? { serviceApi } : {}),
+            ...(tags ? { tags } : {}),
+            ...(queryParams
+                ? {
+                    queryParams: queryParams
+                        .filter((parameter) => parameter.in === "query")
+                        .map((parameter) => ({
+                        name: parameter.name,
+                        type: parameter.type === "number" || parameter.type === "boolean"
+                            ? parameter.type
+                            : "string",
+                        required: parameter.required,
+                        ...(parameter.description ? { description: parameter.description } : {}),
+                    })),
+                }
+                : {}),
+        };
+    }
+    const requestSchema = requestBody?.schemas?.[0]
+        ? buildJsonSchemaFromCatalogSchema(requestBody.schemas[0])
+        : null;
+    return {
+        apiDescription: description,
+        ...(routeOnly ? { routeOnly: true } : {}),
+        ...(registryTopic ? { registryTopic } : {}),
+        ...(serviceApi ? { serviceApi } : {}),
+        ...(tags ? { tags } : {}),
+        ...(requestBody
+            ? {
+                requestBody: {
+                    required: requestBody.required ?? true,
+                    ...(requestBody.description ? { description: requestBody.description } : {}),
+                    ...(requestSchema && typeof requestSchema === "object" ? { schema: requestSchema } : {}),
+                },
+            }
+            : {}),
+    };
+}
+function buildServiceApiPayload(id, definition) {
+    const schemas = definition.schema ? [definition.schema] : [];
+    const response = definition.response ?? {
+        statusCode: "200",
+        description: definition.description,
+        ...(definition.schema?.contentType ? { contentType: definition.schema.contentType } : {}),
+        ...(definition.schema ? { schemas: [definition.schema] } : {}),
+    };
+    return {
+        id,
+        summary: definition.description,
+        description: definition.description,
+        tags: definition.tags ?? [],
+        parameters: definition.queryParams ?? [],
+        headers: [],
+        requestBody: definition.requestBody ?? null,
+        responses: [response],
+        schemas,
+    };
+}
+function getRowValue(row, key) {
+    if (Object.prototype.hasOwnProperty.call(row, key)) {
+        return row[key];
+    }
+    const normalizedKey = key.toLowerCase();
+    const match = Object.keys(row).find((candidate) => candidate.toLowerCase() === normalizedKey);
+    return match ? row[match] : null;
+}
+function buildJsonSchemaFromCatalogSchema(schema) {
+    const leafFields = (schema.fields ?? []).filter((field) => field.type !== "array");
+    const properties = Object.fromEntries(leafFields.map((field) => [
+        field.name,
+        {
+            type: toJsonSchemaType(field.type ?? "string"),
+            ...(field.description ? { description: field.description } : {}),
+            ...(field.format ? { format: field.format } : {}),
+            ...(field.example !== undefined ? { example: field.example } : {}),
+            ...(Array.isArray(field.enumValues) && field.enumValues.length ? { enum: field.enumValues } : {}),
+        },
+    ]));
+    const required = leafFields.filter((field) => field.required === true).map((field) => field.name);
+    return {
+        type: "object",
+        ...(required.length ? { required } : {}),
+        properties,
+    };
+}
+function toJsonSchemaType(type) {
+    switch (type) {
+        case "number":
+        case "integer":
+        case "boolean":
+        case "array":
+        case "object":
+            return type;
+        default:
+            return "string";
+    }
+}
+function buildExamplePayloadsFromFields(fields) {
+    const arrayFields = fields.filter((field) => field.type === "array");
+    const scalarFields = fields.filter((field) => field.type !== "array");
+    if (!scalarFields.length) {
+        return undefined;
+    }
+    if (arrayFields.length === 1 && isGenericListField(arrayFields[0].name)) {
+        const listField = arrayFields[0];
+        const rowFields = scalarFields.filter((field) => field.name !== "count");
+        if (!rowFields.length || rowFields.some((field) => field.example === undefined)) {
+            return undefined;
+        }
+        const payload = {
+            [listField.name]: [Object.fromEntries(rowFields.map((field) => [field.name, field.example]))],
+        };
+        const countField = scalarFields.find((field) => field.name === "count");
+        if (countField) {
+            payload[countField.name] = countField.example ?? 1;
+        }
+        return [payload];
+    }
+    if (scalarFields.some((field) => field.example === undefined)) {
+        return undefined;
+    }
+    return [Object.fromEntries(scalarFields.map((field) => [field.name, field.example]))];
+}
+function isGenericListField(name) {
+    return name === "data" || name === "rows";
+}

package/dist/index.d.ts

@@ -1,3 +1,5 @@
 export { default } from "./uns-api-plugin.js";
 export { UnsApiProxy, type UnsProxyProcessWithApi } from "./uns-api-plugin.js";
 export * from "./api-interfaces.js";
+export * from "./api-event-routing.js";
+export * from "./parquet.js";

package/dist/index.js

@@ -1,3 +1,5 @@
 export { default } from "./uns-api-plugin.js";
 export { UnsApiProxy } from "./uns-api-plugin.js";
 export * from "./api-interfaces.js";
+export * from "./api-event-routing.js";
+export * from "./parquet.js";

package/dist/parquet.d.ts

@@ -0,0 +1,8 @@
+import type { DataCatalogSchemaRegistration } from "./api-interfaces.js";
+export declare function writeSchemaRowsToParquet(input: {
+    rows: Array<Record<string, unknown>>;
+    schema: DataCatalogSchemaRegistration;
+    outputDir?: string;
+    fileName?: string;
+}): Promise<string | null>;
+export declare function buildParquetSchemaFromCatalogSchema(schema: DataCatalogSchemaRegistration): any;

package/dist/parquet.js

@@ -0,0 +1,61 @@
+import { randomUUID } from "crypto";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { ParquetSchema, ParquetWriter } from "parquets";
+import logger from "@uns-kit/core/logger.js";
+const PARQUET_TYPE_MAP = {
+    string: "UTF8",
+    number: "DOUBLE",
+    integer: "INT64",
+    boolean: "BOOLEAN",
+    date: "TIMESTAMP_MILLIS",
+    "date-time": "TIMESTAMP_MILLIS",
+};
+export async function writeSchemaRowsToParquet(input) {
+    try {
+        const outputDir = input.outputDir ?? path.join(os.tmpdir(), "uns-data-offers");
+        const fileName = input.fileName ?? `${randomUUID()}.parquet`;
+        const filePath = path.join(outputDir, fileName);
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+        }
+        const writer = await ParquetWriter.openFile(buildParquetSchemaFromCatalogSchema(input.schema), filePath);
+        for (const row of input.rows) {
+            await writer.appendRow(normalizeParquetRow(row));
+        }
+        await writer.close();
+        return filePath;
+    }
+    catch (error) {
+        logger.error("Failed to write schema-driven parquet:", error);
+        return null;
+    }
+}
+export function buildParquetSchemaFromCatalogSchema(schema) {
+    const schemaDef = {};
+    for (const field of schema.fields ?? []) {
+        const parquetType = toParquetType(field.type ?? "string", field.format ?? null);
+        if (!parquetType) {
+            continue;
+        }
+        schemaDef[field.name] = {
+            type: parquetType,
+            optional: field.required !== true,
+        };
+    }
+    return new ParquetSchema(schemaDef);
+}
+function toParquetType(type, format) {
+    if (format && PARQUET_TYPE_MAP[format]) {
+        return PARQUET_TYPE_MAP[format];
+    }
+    return PARQUET_TYPE_MAP[type] ?? null;
+}
+function normalizeParquetRow(row) {
+    const normalized = {};
+    for (const [key, value] of Object.entries(row)) {
+        normalized[key] = value instanceof Date ? new Date(value) : value;
+    }
+    return normalized;
+}

package/dist/uns-api-plugin.js

@@ -22,9 +22,18 @@ const unsApiPlugin = ({ define }) => {
             unsApiProxy.event.on("unsProxyProducedApiEndpoints", (event) => {
                 internals.processMqttProxy.publish(event.statusTopic, JSON.stringify(event.producedApiEndpoints));
             });
+            unsApiProxy.event.on("unsProxyProducedServiceEndpoints", (event) => {
+                internals.processMqttProxy.publish(event.statusTopic, JSON.stringify(event.producedServiceEndpoints));
+            });
+            unsApiProxy.event.on("unsProxyProducedDataOfferEndpoints", (event) => {
+                internals.processMqttProxy.publish(event.statusTopic, JSON.stringify(event.producedDataOfferEndpoints));
+            });
             unsApiProxy.event.on("unsProxyProducedApiCatchAll", (event) => {
                 internals.processMqttProxy.publish(event.statusTopic, JSON.stringify(event.producedCatchall));
             });
+            unsApiProxy.event.on("unsProxyProducedDataCatalogOffers", (event) => {
+                internals.processMqttProxy.publish(event.statusTopic, JSON.stringify(event.producedDataCatalogOffers));
+            });
             unsApiProxy.event.on("mqttProxyStatus", (event) => {
                 const time = UnsPacket.formatToISO8601(new Date());
                 const unsMessage = { data: { time, value: event.value, uom: event.uom } };

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

@@ -4,6 +4,7 @@ import { UnsTopics } from "@uns-kit/core/uns/uns-topics.js";
 import { IApiProxyOptions, IGetEndpointOptions, IPostEndpointOptions } from "@uns-kit/core/uns/uns-interfaces.js";
 import { UnsAsset } from "@uns-kit/core/uns/uns-asset.js";
 import { UnsObjectType, UnsObjectId } from "@uns-kit/core/uns/uns-object.js";
+import type { DataCatalogOfferRegistration } from "./api-interfaces.js";
 export default class UnsApiProxy extends UnsProxy {
     instanceName: string;
     private topicBuilder;
@@ -18,7 +19,9 @@ export default class UnsApiProxy extends UnsProxy {
     private startedAt;
     private statusInterval;
     private readonly statusIntervalMs;
+    private readonly dataCatalogOffers;
     constructor(processName: string, instanceName: string, options: IApiProxyOptions);
+    getProcessName(): string;
     /**
      * Unregister endpoint
      * @param topic - The API topic
@@ -51,20 +54,27 @@ export default class UnsApiProxy extends UnsProxy {
         tags?: string[];
         queryParams?: IGetEndpointOptions["queryParams"];
     }): Promise<void>;
-    /**
-     * Register a POST endpoint.
-     * @param topic - The API topic
-     * @param attribute - The attribute for the topic.
-     * @param options.apiDescription - Optional description.
-     * @param options.tags - Optional tags.
-     * @param options.requestBody - Optional request body schema for Swagger.
-     */
     post(topic: UnsTopics, asset: UnsAsset, objectType: UnsObjectType, objectId: UnsObjectId, attribute: UnsAttribute, options?: IPostEndpointOptions): Promise<void>;
+    put(topic: UnsTopics, asset: UnsAsset, objectType: UnsObjectType, objectId: UnsObjectId, attribute: UnsAttribute, options?: IPostEndpointOptions): Promise<void>;
+    patch(topic: UnsTopics, asset: UnsAsset, objectType: UnsObjectType, objectId: UnsObjectId, attribute: UnsAttribute, options?: IPostEndpointOptions): Promise<void>;
+    delete(topic: UnsTopics, asset: UnsAsset, objectType: UnsObjectType, objectId: UnsObjectId, attribute: UnsAttribute, options?: IPostEndpointOptions): Promise<void>;
+    private registerMutationEndpoint;
+    registerDataOffer(input: DataCatalogOfferRegistration): void;
     private emitStatusMetrics;
     private registerHealthEndpoint;
+    private getApiEventName;
     private extractBearerToken;
     private getPublicKeyFromJwks;
     private fetchJwksKeys;
     private certFromX5c;
     stop(): Promise<void>;
+    private publishDataCatalogOffer;
+    private emitDataCatalogOffers;
+    private normalizeDataOfferOperation;
+    private normalizeDataOfferParameter;
+    private normalizeDataOfferRequestBody;
+    private normalizeDataOfferResponse;
+    private normalizeDataOfferSchema;
+    private normalizeDataOfferSchemaField;
+    private resolveOfferSchemas;
 }