@uns-kit/api 2.0.45 → 2.0.46

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.45",
+  "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.45"
+    "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": {