@uns-kit/api 2.0.44 → 2.0.46

package/README.md

@@ -117,6 +117,151 @@ api.event.on("apiPostEvent", (event: UnsEvents["apiPostEvent"]) => {
 });
 ```
 
+## Data offer example
+
+```ts
+import "@uns-kit/api";
+import {
+  defineDataCatalogField,
+  defineDataCatalogOfferSource,
+  defineDataCatalogQueryParam,
+  defineDataCatalogSchema,
+  defineServiceApi,
+  projectRowsForDataCatalogSchema,
+  registerApiCatalog,
+  type UnsProxyProcessWithApi,
+} from "@uns-kit/api";
+import { ConfigFile, UnsProxyProcess } from "@uns-kit/core";
+
+const config = await ConfigFile.loadConfig();
+const proc = new UnsProxyProcess(config.infra.host!, {
+  processName: config.uns.processName,
+}) as UnsProxyProcessWithApi;
+
+const api = await proc.createApiProxy("catalog", {
+  jwks: { wellKnownJwksUrl: config.uns.jwksWellKnownUrl! },
+});
+
+const orderRows = [
+  { ORDER_ID: "PO-1001", STATUS: "released" },
+  { ORDER_ID: "PO-1002", STATUS: "finished" },
+];
+
+const productionOrdersSchema = defineDataCatalogSchema({
+  id: "production-orders",
+  title: "Production Orders",
+  contentType: "application/json",
+  fields: [
+    defineDataCatalogField("count", "number", "Number of returned rows"),
+    defineDataCatalogField("data", "array", "Returned rows"),
+    defineDataCatalogField("orderId", "string", "Order id", { sourceKey: "ORDER_ID" }),
+    defineDataCatalogField("status", "string", "Order status", { sourceKey: "STATUS" }),
+  ],
+  examplePayloads: [
+    {
+      count: 1,
+      data: [{ orderId: "PO-1001", status: "released" }],
+    },
+  ],
+});
+
+const productionOrderRowSchema = defineDataCatalogSchema({
+  id: "production-orders-row",
+  title: "Production Order Row",
+  contentType: "application/json",
+  fields: productionOrdersSchema.fields?.filter((field) => field.name !== "count" && field.name !== "data") ?? [],
+});
+
+const serviceApis = {
+  status: defineServiceApi({
+    attribute: "status",
+    method: "GET",
+    description: "Service status endpoint",
+    tags: ["service"],
+    handler: async (event: any) => {
+      event.res.json({ status: "ok" });
+    },
+  }),
+  command: defineServiceApi({
+    attribute: "command",
+    method: "POST",
+    description: "Service command endpoint",
+    tags: ["service"],
+    requestBody: {
+      required: true,
+      description: "Command payload",
+      contentType: "application/json",
+      schemas: [
+        defineDataCatalogSchema({
+          id: "service-command-request",
+          title: "Service Command Request",
+          contentType: "application/json",
+          fields: [
+            defineDataCatalogField("command", "string", "Command name", { required: true, example: "refresh-cache" }),
+            defineDataCatalogField("target", "string", "Optional target", { example: "orders" }),
+          ],
+        }),
+      ],
+    },
+    handler: async (event: any) => {
+      const { command, target } = event.req.body ?? {};
+      if (!command) {
+        return event.res.status(400).json({ error: "Missing command" });
+      }
+
+      event.res.json({
+        status: "accepted",
+        received: {
+          command,
+          ...(target ? { target } : {}),
+        },
+      });
+    },
+  }),
+};
+
+const dataOfferSources = {
+  productionOrders: defineDataCatalogOfferSource({
+    offerId: "production-orders",
+    topic: "factory/demo/app",
+    asset: "orders",
+    objectType: "dataset",
+    objectId: "production",
+    attribute: "list",
+    displayName: "Production Orders",
+    description: "Browse production orders.",
+    method: "GET",
+    tags: ["orders"],
+    queryParams: [
+      defineDataCatalogQueryParam("status", "Optional status filter"),
+    ],
+    schema: productionOrdersSchema,
+    response: {
+      statusCode: "200",
+      contentType: "application/json",
+    },
+    handler: async (event: any) => {
+      const statusFilter = String(event.req.query.status ?? "").trim().toLowerCase();
+      const filteredRows = statusFilter
+        ? orderRows.filter((row) => row.STATUS.toLowerCase() === statusFilter)
+        : orderRows;
+      const data = projectRowsForDataCatalogSchema(filteredRows, productionOrderRowSchema);
+
+      event.res.json({
+        count: data.length,
+        data,
+      });
+    },
+  }),
+};
+
+await registerApiCatalog(api, {
+  serviceApis,
+  dataOfferSources,
+  context: undefined,
+});
+```
+
 ## Endpoint signature
 
 ```

package/dist/api-event-routing.d.ts

@@ -0,0 +1,39 @@
+import type { UnsEvents } from "@uns-kit/core/uns/uns-interfaces.js";
+import type { ApiInteractionDefinition, ApiInteractionMethod, DataCatalogOfferRegistration, DataCatalogOfferSourceRegistration, ServiceApiRegistration } from "./api-interfaces.js";
+import type UnsApiProxy from "./uns-api-proxy.js";
+type ApiEventEnvelope = {
+    req: any;
+    res: any;
+};
+type ApiEventByMethod = {
+    GET: UnsEvents["apiGetEvent"];
+    POST: UnsEvents["apiPostEvent"];
+    PUT: ApiEventEnvelope;
+    PATCH: ApiEventEnvelope;
+    DELETE: ApiEventEnvelope;
+};
+export type ApiHandler<Method extends ApiInteractionMethod = ApiInteractionMethod, Context = void> = (event: ApiEventByMethod[Method], context: Context) => Promise<void>;
+export type RegisterApiEventsOptions = {
+    notFoundMessage?: string;
+    onError?: (input: {
+        method: ApiInteractionMethod;
+        reqPath?: string;
+        error: unknown;
+    }) => void;
+};
+export type RegisterApiCatalogOptions<Context, Handler, ServiceApis extends Record<string, ServiceApiRegistration<Handler>>, OfferSources extends Record<string, DataCatalogOfferSourceRegistration<Handler>>> = {
+    serviceApis?: ServiceApis;
+    dataOfferSources?: OfferSources;
+    context: Context;
+    dataCatalogOffers?: DataCatalogOfferRegistration[];
+    options?: RegisterApiEventsOptions;
+};
+export declare function normalizeApiRequestPath(path?: string): string | undefined;
+export declare function registerApiCatalog<Context, Handler, ServiceApis extends Record<string, ServiceApiRegistration<Handler>>, OfferSources extends Record<string, DataCatalogOfferSourceRegistration<Handler>>>(apiInput: UnsApiProxy, input: RegisterApiCatalogOptions<Context, Handler, ServiceApis, OfferSources>): Promise<{
+    serviceApiRoutes: ApiInteractionDefinition<Handler>[];
+    dataOfferRoutes: ApiInteractionDefinition<Handler>[];
+    dataCatalogOffers: DataCatalogOfferRegistration[];
+}>;
+export declare function registerApiInteractions<Handler>(apiInput: UnsApiProxy, routes: ApiInteractionDefinition<Handler>[]): Promise<void>;
+export declare function registerApiEvents<Context, Handler>(apiInput: UnsApiProxy, routes: ApiInteractionDefinition<Handler>[], context: Context, options?: RegisterApiEventsOptions): void;
+export {};

package/dist/api-event-routing.js

@@ -0,0 +1,88 @@
+import { buildApiInteractionTopicPath, buildApiInteractionsFromDataOfferSources, buildDataCatalogOffersFromSources, buildServiceApiInteractions, } from "./api-interfaces.js";
+const EVENT_NAME_BY_METHOD = {
+    GET: "apiGetEvent",
+    POST: "apiPostEvent",
+    PUT: "apiPutEvent",
+    PATCH: "apiPatchEvent",
+    DELETE: "apiDeleteEvent",
+};
+export function normalizeApiRequestPath(path) {
+    const normalized = path?.replace(/^\/+|\/+$/g, "");
+    return normalized?.length ? normalized : undefined;
+}
+export async function registerApiCatalog(apiInput, input) {
+    const serviceApiRoutes = Object.values(buildServiceApiInteractions(apiInput.getProcessName(), input.serviceApis ?? {}));
+    const dataOfferRoutes = Object.values(buildApiInteractionsFromDataOfferSources(input.dataOfferSources ?? {}));
+    const dataCatalogOffers = input.dataCatalogOffers ?? buildDataCatalogOffersFromSources(input.dataOfferSources ?? {});
+    const allRoutes = [...serviceApiRoutes, ...dataOfferRoutes];
+    await registerApiInteractions(apiInput, allRoutes);
+    for (const offer of dataCatalogOffers) {
+        apiInput.registerDataOffer(offer);
+    }
+    registerApiEvents(apiInput, allRoutes, input.context, input.options);
+    return { serviceApiRoutes, dataOfferRoutes, dataCatalogOffers };
+}
+export async function registerApiInteractions(apiInput, routes) {
+    for (const route of routes) {
+        switch (route.method) {
+            case "GET":
+                await apiInput.get(route.topic, route.asset, route.objectType, route.objectId, route.attribute, route.options);
+                break;
+            case "POST":
+                await apiInput.post(route.topic, route.asset, route.objectType, route.objectId, route.attribute, route.options);
+                break;
+            case "PUT":
+                await apiInput.put(route.topic, route.asset, route.objectType, route.objectId, route.attribute, route.options);
+                break;
+            case "PATCH":
+                await apiInput.patch(route.topic, route.asset, route.objectType, route.objectId, route.attribute, route.options);
+                break;
+            case "DELETE":
+                await apiInput.delete(route.topic, route.asset, route.objectType, route.objectId, route.attribute, route.options);
+                break;
+            default:
+                throw new Error(`Unsupported API method: ${route.method}`);
+        }
+    }
+}
+export function registerApiEvents(apiInput, routes, context, options = {}) {
+    const handlersByMethod = buildRouteHandlerIndex(routes);
+    bindMethodEvent(apiInput, "GET", handlersByMethod.GET, context, options);
+    bindMethodEvent(apiInput, "POST", handlersByMethod.POST, context, options);
+    bindMethodEvent(apiInput, "PUT", handlersByMethod.PUT, context, options);
+    bindMethodEvent(apiInput, "PATCH", handlersByMethod.PATCH, context, options);
+    bindMethodEvent(apiInput, "DELETE", handlersByMethod.DELETE, context, options);
+}
+function buildRouteHandlerIndex(routes) {
+    return routes.reduce((acc, route) => {
+        acc[route.method][buildApiInteractionTopicPath(route)] = route.handler;
+        return acc;
+    }, {
+        GET: {},
+        POST: {},
+        PUT: {},
+        PATCH: {},
+        DELETE: {},
+    });
+}
+function bindMethodEvent(apiInput, method, handlers, context, options) {
+    const eventName = EVENT_NAME_BY_METHOD[method];
+    apiInput.event.on(eventName, async (event) => {
+        const reqPath = normalizeApiRequestPath(event.req.path);
+        const handler = reqPath ? handlers[reqPath] : undefined;
+        await executeHandler(event, handler, context, method, reqPath, options);
+    });
+}
+async function executeHandler(event, handler, context, method, reqPath, options) {
+    if (!handler) {
+        event.res.status(404).send(options.notFoundMessage ?? "API handler not found");
+        return;
+    }
+    try {
+        await handler(event, context);
+    }
+    catch (error) {
+        options.onError?.({ method, reqPath, error });
+        event.res.status(500).send("Server error");
+    }
+}

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;
 }

package/dist/uns-api-proxy.js

@@ -31,6 +31,21 @@ const buildSwaggerPath = (base, processName, instanceName) => {
     }
     return `${baseWithProcess}/${instanceName}/swagger.json`.replace(/\/{2,}/g, "/");
 };
+const normalizeStringArray = (value) => Array.isArray(value)
+    ? Array.from(new Set(value
+        .map((entry) => (typeof entry === "string" ? entry.trim() : ""))
+        .filter((entry) => entry.length > 0)))
+    : [];
+const normalizePathValue = (value) => {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return null;
+    }
+    return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+};
 export default class UnsApiProxy extends UnsProxy {
     instanceName;
     topicBuilder;
@@ -45,6 +60,7 @@ export default class UnsApiProxy extends UnsProxy {
     startedAt;
     statusInterval = null;
     statusIntervalMs = 10_000;
+    dataCatalogOffers = new Map();
     constructor(processName, instanceName, options) {
         super();
         this.options = options;
@@ -76,6 +92,9 @@ export default class UnsApiProxy extends UnsProxy {
         setTimeout(() => this.emitStatusMetrics(), 0);
         this.statusInterval = setInterval(() => this.emitStatusMetrics(), this.statusIntervalMs);
     }
+    getProcessName() {
+        return this.processName;
+    }
     /**
      * Unregister endpoint
      * @param topic - The API topic
@@ -138,11 +157,15 @@ export default class UnsApiProxy extends UnsProxy {
                 timestamp: time,
                 topic: topic,
                 attribute: attribute,
+                routeOnly: options?.routeOnly === true,
+                registryTopic: options?.registryTopic ??
+                    "api-endpoints",
                 apiHost: `http://${ip}:${port}`,
                 apiEndpoint: apiPath,
                 apiMethod: "GET",
                 apiQueryParams: options.queryParams,
                 apiDescription: options?.apiDescription,
+                serviceApi: options?.serviceApi ?? null,
                 attributeType: UnsAttributeType.Api,
                 apiSwaggerEndpoint: swaggerPath,
                 asset,
@@ -383,15 +406,19 @@ export default class UnsApiProxy extends UnsProxy {
             swaggerPath,
         });
     }
-    /**
-     * 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.
-     */
     async post(topic, asset, objectType, objectId, attribute, options) {
+        await this.registerMutationEndpoint("POST", topic, asset, objectType, objectId, attribute, options);
+    }
+    async put(topic, asset, objectType, objectId, attribute, options) {
+        await this.registerMutationEndpoint("PUT", topic, asset, objectType, objectId, attribute, options);
+    }
+    async patch(topic, asset, objectType, objectId, attribute, options) {
+        await this.registerMutationEndpoint("PATCH", topic, asset, objectType, objectId, attribute, options);
+    }
+    async delete(topic, asset, objectType, objectId, attribute, options) {
+        await this.registerMutationEndpoint("DELETE", topic, asset, objectType, objectId, attribute, options);
+    }
+    async registerMutationEndpoint(method, topic, asset, objectType, objectId, attribute, options) {
         while (this.app.server.listening === false) {
             await new Promise((resolve) => setTimeout(resolve, 100));
         }
@@ -399,6 +426,7 @@ export default class UnsApiProxy extends UnsProxy {
         const fullPath = buildUnsRoutePath(topic, asset, objectType, objectId, attribute);
         const apiPath = `${this.apiBasePrefix}${fullPath}`.replace(/\/{2,}/g, "/");
         const swaggerPath = buildSwaggerPath(this.swaggerBasePrefix, this.processName, this.instanceName);
+        const methodKey = method.toLowerCase();
         try {
             const addressInfo = this.app.server.address();
             let ip;
@@ -415,11 +443,15 @@ export default class UnsApiProxy extends UnsProxy {
                 timestamp: time,
                 topic,
                 attribute,
+                routeOnly: options?.routeOnly === true,
+                registryTopic: options?.registryTopic ??
+                    "api-endpoints",
                 apiHost: `http://${ip}:${port}`,
                 apiEndpoint: apiPath,
-                apiMethod: "POST",
+                apiMethod: method,
                 apiQueryParams: [],
                 apiDescription: options?.apiDescription,
+                serviceApi: options?.serviceApi ?? null,
                 attributeType: UnsAttributeType.Api,
                 apiSwaggerEndpoint: swaggerPath,
                 asset,
@@ -427,10 +459,11 @@ export default class UnsApiProxy extends UnsProxy {
                 objectId,
             });
             const handler = (req, res) => {
-                this.event.emit("apiPostEvent", { req, res });
+                this.event.emit(this.getApiEventName(method), { req, res });
             };
+            const routerMethod = this.app.router[methodKey].bind(this.app.router);
             if (this.options?.jwks?.wellKnownJwksUrl) {
-                this.app.router.post(fullPath, async (req, res) => {
+                routerMethod(fullPath, async (req, res) => {
                     try {
                         const token = this.extractBearerToken(req, res);
                         if (!token)
@@ -451,13 +484,13 @@ export default class UnsApiProxy extends UnsProxy {
                         }
                         handler(req, res);
                     }
-                    catch (err) {
+                    catch (_err) {
                         return res.status(401).json({ error: "Invalid token" });
                     }
                 });
             }
             else if (this.options?.jwtSecret) {
-                this.app.router.post(fullPath, (req, res) => {
+                routerMethod(fullPath, (req, res) => {
                     const authHeader = req.headers["authorization"];
                     if (!authHeader || !authHeader.startsWith("Bearer ")) {
                         return res.status(401).json({ error: "Missing or invalid Authorization header" });
@@ -478,19 +511,19 @@ export default class UnsApiProxy extends UnsProxy {
                         }
                         handler(req, res);
                     }
-                    catch (err) {
+                    catch (_err) {
                         return res.status(401).json({ error: "Invalid token" });
                     }
                 });
             }
             else {
-                this.app.router.post(fullPath, handler);
+                routerMethod(fullPath, handler);
             }
             if (this.app.swaggerSpec) {
                 const requestBody = options?.requestBody;
                 this.app.swaggerSpec.paths = this.app.swaggerSpec.paths || {};
                 this.app.swaggerSpec.paths[apiPath] = this.app.swaggerSpec.paths[apiPath] || {};
-                this.app.swaggerSpec.paths[apiPath].post = {
+                this.app.swaggerSpec.paths[apiPath][methodKey] = {
                     summary: options?.apiDescription || "No description",
                     tags: options?.tags || [],
                     ...(requestBody
@@ -516,9 +549,58 @@ export default class UnsApiProxy extends UnsProxy {
             }
         }
         catch (error) {
-            logger.error(`${this.instanceNameWithSuffix} - Error registering POST route ${fullPath}: ${error.message}`);
+            logger.error(`${this.instanceNameWithSuffix} - Error registering ${method} route ${fullPath}: ${error.message}`);
         }
     }
+    registerDataOffer(input) {
+        const offerId = typeof input.offerId === "string" ? input.offerId.trim() : "";
+        const displayName = typeof input.displayName === "string" ? input.displayName.trim() : "";
+        if (!offerId || !displayName) {
+            throw new Error("Data catalog offer requires non-empty offerId and displayName.");
+        }
+        const offerSchemas = (Array.isArray(input.schemas) ? input.schemas : []).map((schema) => this.normalizeDataOfferSchema(schema));
+        const offerSchemaIndex = new Map(offerSchemas.map((schema) => [schema.id, schema]));
+        const normalizedOperations = (Array.isArray(input.operations) ? input.operations : [])
+            .map((operation, index) => this.normalizeDataOfferOperation(operation, offerId, index, offerSchemaIndex))
+            .filter((operation) => Boolean(operation));
+        if (!normalizedOperations.length) {
+            throw new Error(`Data catalog offer ${offerId} requires at least one operation.`);
+        }
+        const basePaths = Array.from(new Set([
+            ...(Array.isArray(input.basePaths) ? input.basePaths.map((entry) => normalizePathValue(entry)) : []),
+            ...normalizedOperations.map((operation) => {
+                const segments = operation.path.split("/").filter(Boolean);
+                if (segments.length <= 1) {
+                    return operation.path;
+                }
+                return `/${segments.slice(0, -1).join("/")}`;
+            }),
+        ].filter((value) => Boolean(value))));
+        this.publishDataCatalogOffer({
+            offerId,
+            displayName,
+            description: typeof input.description === "string" ? input.description.trim() || null : null,
+            owner: typeof input.owner === "string" ? input.owner.trim() || null : null,
+            status: typeof input.status === "string" && input.status.trim() ? input.status.trim() : "available",
+            tags: normalizeStringArray(input.tags),
+            categories: normalizeStringArray(input.categories),
+            microserviceName: typeof input.microserviceName === "string" && input.microserviceName.trim()
+                ? input.microserviceName.trim()
+                : this.processName,
+            version: typeof input.version === "string" && input.version.trim() ? input.version.trim() : packageJson.version,
+            swaggerPath: normalizePathValue(input.swaggerPath),
+            basePaths,
+            operations: normalizedOperations,
+            schemas: offerSchemas,
+            metadata: input.metadata ?? null,
+            packageName: packageJson.name,
+            processName: this.processName,
+            processVersion: packageJson.version,
+            instanceName: this.instanceName,
+            controllerName: process.env["UNS_CONTROLLER_NAME"] ?? null,
+            controllerPublicBase: process.env["UNS_CONTROLLER_PUBLIC_BASE"] ?? process.env["UNS_PUBLIC_BASE"] ?? null,
+        });
+    }
     emitStatusMetrics() {
         const uptimeMinutes = Math.round((Date.now() - this.startedAt) / 60000);
         // Process-level status
@@ -547,6 +629,7 @@ export default class UnsApiProxy extends UnsProxy {
             uom: DataSizeMeasurements.Bit,
             statusTopic: this.instanceStatusTopic + "alive",
         });
+        this.emitDataCatalogOffers();
     }
     registerHealthEndpoint() {
         const routePath = "/status";
@@ -575,6 +658,20 @@ export default class UnsApiProxy extends UnsProxy {
             };
         }
     }
+    getApiEventName(method) {
+        switch (method) {
+            case "GET":
+                return "apiGetEvent";
+            case "POST":
+                return "apiPostEvent";
+            case "PUT":
+                return "apiPutEvent";
+            case "PATCH":
+                return "apiPatchEvent";
+            case "DELETE":
+                return "apiDeleteEvent";
+        }
+    }
     extractBearerToken(req, res) {
         const authHeader = req.headers["authorization"];
         if (!authHeader || !authHeader.startsWith("Bearer ")) {
@@ -647,4 +744,117 @@ export default class UnsApiProxy extends UnsProxy {
         }
         await super.stop();
     }
+    publishDataCatalogOffer(offer) {
+        const offerId = typeof offer.offerId === "string" ? offer.offerId.trim() : "";
+        if (!offerId) {
+            return;
+        }
+        this.dataCatalogOffers.set(offerId, offer);
+        this.emitDataCatalogOffers();
+        logger.info(`${this.instanceNameWithSuffix} - Registered data catalog offer: ${offerId}`);
+    }
+    emitDataCatalogOffers() {
+        if (this.instanceStatusTopic === "" || this.dataCatalogOffers.size === 0) {
+            return;
+        }
+        this.event.emit("unsProxyProducedDataCatalogOffers", {
+            producedDataCatalogOffers: [...this.dataCatalogOffers.values()],
+            statusTopic: this.instanceStatusTopic + "data-catalog-offers",
+        });
+    }
+    normalizeDataOfferOperation(operation, offerId, index, offerSchemaIndex) {
+        const method = typeof operation.method === "string" ? operation.method.trim().toUpperCase() : "";
+        const path = normalizePathValue(operation.path);
+        if (!method || !path) {
+            return null;
+        }
+        return {
+            id: typeof operation.id === "string" && operation.id.trim() ? operation.id.trim() : `${offerId}-${method.toLowerCase()}-${index + 1}`,
+            method,
+            path,
+            summary: typeof operation.summary === "string" ? operation.summary.trim() || null : null,
+            description: typeof operation.description === "string" ? operation.description.trim() || null : null,
+            tags: normalizeStringArray(operation.tags),
+            deprecated: operation.deprecated === true,
+            parameters: (Array.isArray(operation.parameters) ? operation.parameters : []).map((parameter) => this.normalizeDataOfferParameter(parameter)),
+            headers: (Array.isArray(operation.headers) ? operation.headers : []).map((parameter) => this.normalizeDataOfferParameter(parameter)),
+            requestBody: operation.requestBody ? this.normalizeDataOfferRequestBody(operation.requestBody, offerSchemaIndex) : null,
+            responses: (Array.isArray(operation.responses) ? operation.responses : []).map((response) => this.normalizeDataOfferResponse(response, offerSchemaIndex)),
+        };
+    }
+    normalizeDataOfferParameter(parameter) {
+        return {
+            name: typeof parameter.name === "string" ? parameter.name.trim() : "",
+            in: typeof parameter.in === "string" ? parameter.in.trim() : "query",
+            required: parameter.required === true,
+            description: typeof parameter.description === "string" ? parameter.description.trim() || null : null,
+            type: typeof parameter.type === "string" && parameter.type.trim() ? parameter.type.trim() : "string",
+            format: typeof parameter.format === "string" ? parameter.format.trim() || null : null,
+            nullable: parameter.nullable === true,
+            example: parameter.example ?? null,
+            enumValues: normalizeStringArray(parameter.enumValues),
+            schema: parameter.schema ?? null,
+        };
+    }
+    normalizeDataOfferRequestBody(requestBody, offerSchemaIndex) {
+        return {
+            required: requestBody.required === true,
+            description: typeof requestBody.description === "string" ? requestBody.description.trim() || null : null,
+            contentType: typeof requestBody.contentType === "string" ? requestBody.contentType.trim() || null : null,
+            schemas: this.resolveOfferSchemas(requestBody.schemas, requestBody.schemaIds, offerSchemaIndex),
+        };
+    }
+    normalizeDataOfferResponse(response, offerSchemaIndex) {
+        return {
+            statusCode: typeof response.statusCode === "string" ? response.statusCode.trim() : "",
+            description: typeof response.description === "string" ? response.description.trim() || null : null,
+            contentType: typeof response.contentType === "string" ? response.contentType.trim() || null : null,
+            schemas: this.resolveOfferSchemas(response.schemas, response.schemaIds, offerSchemaIndex),
+            examplePayloads: Array.isArray(response.examplePayloads) ? response.examplePayloads : [],
+            headers: (Array.isArray(response.headers) ? response.headers : []).map((parameter) => this.normalizeDataOfferParameter(parameter)),
+        };
+    }
+    normalizeDataOfferSchema(schema) {
+        return {
+            id: typeof schema.id === "string" ? schema.id.trim() : "",
+            title: typeof schema.title === "string" ? schema.title.trim() : "",
+            kind: typeof schema.kind === "string" && schema.kind.trim() ? schema.kind.trim() : "schema",
+            source: typeof schema.source === "string" && schema.source.trim() ? schema.source.trim() : "registered",
+            contentType: typeof schema.contentType === "string" ? schema.contentType.trim() || null : null,
+            rootType: typeof schema.rootType === "string" && schema.rootType.trim() ? schema.rootType.trim() : "object",
+            nullable: schema.nullable === true,
+            description: typeof schema.description === "string" ? schema.description.trim() || null : null,
+            fields: (Array.isArray(schema.fields) ? schema.fields : []).map((field) => this.normalizeDataOfferSchemaField(field)),
+            examplePayloads: Array.isArray(schema.examplePayloads) ? schema.examplePayloads : [],
+        };
+    }
+    normalizeDataOfferSchemaField(field) {
+        const defaultName = typeof field.name === "string" ? field.name.trim() : "";
+        const path = typeof field.path === "string" && field.path.trim() ? field.path.trim() : defaultName;
+        return {
+            path,
+            name: defaultName || (path.split(".").at(-1) ?? path),
+            type: typeof field.type === "string" && field.type.trim() ? field.type.trim() : "string",
+            format: typeof field.format === "string" ? field.format.trim() || null : null,
+            nullable: field.nullable === true,
+            required: field.required === true,
+            description: typeof field.description === "string" ? field.description.trim() || null : null,
+            enumValues: normalizeStringArray(field.enumValues),
+            example: field.example ?? null,
+        };
+    }
+    resolveOfferSchemas(inlineSchemas, schemaIds, offerSchemaIndex) {
+        const result = (Array.isArray(inlineSchemas) ? inlineSchemas : []).map((schema) => this.normalizeDataOfferSchema(schema));
+        for (const schemaId of Array.isArray(schemaIds) ? schemaIds : []) {
+            const normalizedId = typeof schemaId === "string" ? schemaId.trim() : "";
+            if (!normalizedId) {
+                continue;
+            }
+            const resolved = offerSchemaIndex.get(normalizedId);
+            if (resolved && !result.some((schema) => schema.id === resolved.id)) {
+                result.push(resolved);
+            }
+        }
+        return result;
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uns-kit/api",
-  "version": "2.0.44",
+  "version": "2.0.46",
   "description": "Express-powered API gateway plugin for UnsProxyProcess with JWT/JWKS support.",
   "type": "module",
   "license": "MIT",
@@ -31,16 +31,18 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
-    "jsonwebtoken": "^9.0.2",
     "cookie-parser": "^1.4.7",
     "express": "^5.1.0",
+    "jsonwebtoken": "^9.0.2",
     "multer": "^2.0.2",
-    "@uns-kit/core": "2.0.44"
+    "parquets": "^0.10.10",
+    "uuid": "^14.0.0",
+    "@uns-kit/core": "2.0.46"
   },
   "devDependencies": {
-    "@types/jsonwebtoken": "^9.0.10",
     "@types/cookie-parser": "^1.4.9",
     "@types/express": "^5.0.3",
+    "@types/jsonwebtoken": "^9.0.10",
     "@types/multer": "^2.0.0"
   },
   "scripts": {