@twin.org/api-processors 0.0.1-next.8 → 0.0.1

package/dist/cjs/index.cjs

@@ -10,11 +10,15 @@ var loggingModels = require('@twin.org/logging-models');
 /**
  * Process the REST request and hands it on to the route handler.
  */
-class RouteProcessor {
+class RestRouteProcessor {
+    /**
+     * The namespace supported by the processor.
+     */
+    static NAMESPACE = "rest-route";
     /**
      * Runtime name for the class.
      */
-    CLASS_NAME = "RouteProcessor";
+    CLASS_NAME = "RestRouteProcessor";
     /**
      * Include the stack with errors.
      * @internal
@@ -23,8 +27,6 @@ class RouteProcessor {
     /**
      * Create a new instance of RouteProcessor.
      * @param options Options for the processor.
-     * @param options.config The configuration for the processor.
-     * @returns Promise that resolves when the processor is initialized.
      */
     constructor(options) {
         this._includeErrorStack = options?.config?.includeErrorStack ?? false;
@@ -112,42 +114,78 @@ class RouteProcessor {
     }
 }
 
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
 /**
- * Adds a static user identity to the request context.
+ * Process the socket request and hands it on to the route handler.
  */
-class StaticUserIdentityProcessor {
+class SocketRouteProcessor {
+    /**
+     * The namespace supported by the processor.
+     */
+    static NAMESPACE = "socket-route";
     /**
      * Runtime name for the class.
      */
-    CLASS_NAME = "StaticUserIdentityProcessor";
+    CLASS_NAME = "SocketRouteProcessor";
     /**
-     * The fixed identity for request context.
+     * Include the stack with errors.
      * @internal
      */
-    _userIdentity;
+    _includeErrorStack;
     /**
-     * Create a new instance of StaticIdentityProcessor.
+     * Create a new instance of SocketRouteProcessor.
      * @param options Options for the processor.
-     * @param options.config The configuration for the processor.
-     * @returns Promise that resolves when the processor is initialized.
      */
     constructor(options) {
-        core.Guards.object(this.CLASS_NAME, "options", options);
-        core.Guards.object(this.CLASS_NAME, "options.config", options.config);
-        core.Guards.stringValue(this.CLASS_NAME, "options.config.userIdentity", options.config.userIdentity);
-        this._userIdentity = options.config.userIdentity;
+        this._includeErrorStack = options?.config?.includeErrorStack ?? false;
     }
     /**
-     * Pre process the REST request for the specified route.
+     * Process the REST request for the specified route.
      * @param request The incoming request.
      * @param response The outgoing response.
      * @param route The route to process.
      * @param requestIdentity The identity context for the request.
      * @param processorState The state handed through the processors.
+     * @param responseEmitter The function to emit a response.
      */
-    async pre(request, response, route, requestIdentity, processorState) {
-        if (!core.Is.empty(route) && !(route.skipAuth ?? false)) {
-            requestIdentity.userIdentity = this._userIdentity;
+    async process(request, response, route, requestIdentity, processorState, responseEmitter) {
+        // Don't handle the route if another processor has already set the response
+        // status code e.g. from an auth processor
+        if (core.Is.empty(response.statusCode)) {
+            if (core.Is.empty(route)) {
+                apiModels.HttpErrorHelper.buildResponse(response, {
+                    name: core.NotFoundError.CLASS_NAME,
+                    message: `${this.CLASS_NAME}.routeNotFound`,
+                    properties: {
+                        notFoundId: request.url
+                    }
+                }, web.HttpStatusCode.notFound);
+            }
+            else {
+                try {
+                    const req = {
+                        pathParams: request.pathParams,
+                        query: request.query,
+                        body: request.body
+                    };
+                    await route.handler({
+                        ...requestIdentity,
+                        serverRequest: request,
+                        processorState
+                    }, req, async (topic, restRouteResponse) => {
+                        response.headers = restRouteResponse?.headers;
+                        response.body = restRouteResponse?.body;
+                        response.statusCode =
+                            restRouteResponse.statusCode ?? response.statusCode ?? web.HttpStatusCode.ok;
+                        await responseEmitter(topic, response);
+                    });
+                }
+                catch (err) {
+                    const { error, httpStatusCode } = apiModels.HttpErrorHelper.processError(err, this._includeErrorStack);
+                    apiModels.HttpErrorHelper.buildResponse(response, error, httpStatusCode);
+                }
+            }
         }
     }
 }
@@ -156,6 +194,10 @@ class StaticUserIdentityProcessor {
  * Adds a node identity to the request identity.
  */
 class NodeIdentityProcessor {
+    /**
+     * The namespace supported by the processor.
+     */
+    static NAMESPACE = "node-identity";
     /**
      * Runtime name for the class.
      */
@@ -188,10 +230,56 @@ class NodeIdentityProcessor {
     }
 }
 
+/**
+ * Adds a static user identity to the request context.
+ */
+class StaticUserIdentityProcessor {
+    /**
+     * The namespace supported by the processor.
+     */
+    static NAMESPACE = "static-user-identity";
+    /**
+     * Runtime name for the class.
+     */
+    CLASS_NAME = "StaticUserIdentityProcessor";
+    /**
+     * The fixed identity for request context.
+     * @internal
+     */
+    _userIdentity;
+    /**
+     * Create a new instance of StaticIdentityProcessor.
+     * @param options Options for the processor.
+     */
+    constructor(options) {
+        core.Guards.object(this.CLASS_NAME, "options", options);
+        core.Guards.object(this.CLASS_NAME, "options.config", options.config);
+        core.Guards.stringValue(this.CLASS_NAME, "options.config.userIdentity", options.config.userIdentity);
+        this._userIdentity = options.config.userIdentity;
+    }
+    /**
+     * Pre process the REST request for the specified route.
+     * @param request The incoming request.
+     * @param response The outgoing response.
+     * @param route The route to process.
+     * @param requestIdentity The identity context for the request.
+     * @param processorState The state handed through the processors.
+     */
+    async pre(request, response, route, requestIdentity, processorState) {
+        if (!core.Is.empty(route) && !(route.skipAuth ?? false)) {
+            requestIdentity.userIdentity = this._userIdentity;
+        }
+    }
+}
+
 /**
  * Process the REST request and log its information.
  */
 class LoggingProcessor {
+    /**
+     * The namespace supported by the processor.
+     */
+    static NAMESPACE = "logging";
     /**
      * Runtime name for the class.
      */
@@ -207,15 +295,24 @@ class LoggingProcessor {
      */
     _includeBody;
     /**
-     * Create a new instance of RequestLoggingProcessor.
+     * Show the full base64 content for data, default to abbreviate.
+     * @internal
+     */
+    _fullBase64;
+    /**
+     * List of property names to obfuscate, defaults to "password".
+     * @internal
+     */
+    _obfuscateProperties;
+    /**
+     * Create a new instance of LoggingProcessor.
      * @param options Options for the processor.
-     * @param options.loggingConnectorType The type for the logging connector, defaults to "logging".
-     * @param options.config The configuration for the processor.
-     * @returns Promise that resolves when the processor is initialized.
      */
     constructor(options) {
         this._loggingConnector = loggingModels.LoggingConnectorFactory.get(options?.loggingConnectorType ?? "logging");
         this._includeBody = options?.config?.includeBody ?? false;
+        this._fullBase64 = options?.config?.fullBase64 ?? false;
+        this._obfuscateProperties = options?.config?.obfuscateProperties ?? ["password"];
     }
     /**
      * Pre process the REST request for the specified route.
@@ -228,12 +325,28 @@ class LoggingProcessor {
     async pre(request, response, route, requestIdentity, processorState) {
         const now = process.hrtime.bigint();
         processorState.requestStart = now;
+        const contentType = request.headers?.[web.HeaderTypes.ContentType];
+        const isJson = core.Is.stringValue(contentType)
+            ? contentType.includes(web.MimeTypes.Json) || contentType.includes(web.MimeTypes.JsonLd)
+            : false;
+        let requestUrl = "";
+        if (core.Is.stringValue(request.url)) {
+            // Socket paths do not have a prefix so just use the whole url.
+            if (request.url.startsWith("http")) {
+                requestUrl = new URL(request.url).pathname;
+            }
+            else {
+                requestUrl = request.url;
+            }
+        }
         await this._loggingConnector.log({
             level: "info",
             source: this.CLASS_NAME,
             ts: Date.now(),
-            message: `===> ${request.method} ${request.url ? new URL(request.url).pathname : ""}`,
-            data: this._includeBody ? request?.body : undefined
+            message: `===> ${request.method} ${requestUrl}`,
+            data: this._includeBody && isJson
+                ? this.processJson("body", core.ObjectHelper.clone(request?.body))
+                : undefined
         });
     }
     /**
@@ -248,11 +361,13 @@ class LoggingProcessor {
         let data;
         if (this._includeBody) {
             const contentType = response.headers?.[web.HeaderTypes.ContentType];
-            const isJson = contentType?.includes(`${web.MimeTypes.Json}; charset=utf-8`);
+            const isJson = core.Is.stringValue(contentType)
+                ? contentType.includes(web.MimeTypes.Json) || contentType.includes(web.MimeTypes.JsonLd)
+                : false;
             const contentLength = response.headers?.[web.HeaderTypes.ContentLength];
             if (isJson) {
                 data = {
-                    body: response.body
+                    body: this.processJson("body", core.ObjectHelper.clone(response.body))
                 };
             }
             else {
@@ -274,19 +389,86 @@ class LoggingProcessor {
         const start = core.Coerce.bigint(processorState.requestStart) ?? now;
         const elapsed = now - start;
         const elapsedMicroSeconds = Math.floor(Number(elapsed) / 1000);
+        let requestUrl = "";
+        if (core.Is.stringValue(request.url)) {
+            // Socket paths do not have a prefix so just use the whole url.
+            if (request.url.startsWith("http")) {
+                requestUrl = new URL(request.url).pathname;
+            }
+            else {
+                requestUrl = request.url;
+            }
+        }
         await this._loggingConnector.log({
             level: core.Is.number(response.statusCode) && response.statusCode >= web.HttpStatusCode.badRequest
                 ? "error"
                 : "info",
             source: this.CLASS_NAME,
             ts: Date.now(),
-            message: `<=== ${response.statusCode ?? ""} ${request.method} ${request.url ? new URL(request.url).pathname : ""} duration: ${elapsedMicroSeconds}µs`,
+            message: `<=== ${response.statusCode ?? ""} ${request.method} ${requestUrl} duration: ${elapsedMicroSeconds}µs`,
             data
         });
     }
+    /**
+     * Process the JSON.
+     * @param propValue The property to process.
+     * @returns The processed property.
+     * @internal
+     */
+    processJson(propName, propValue) {
+        if (core.Is.array(propValue)) {
+            for (let i = 0; i < propValue.length; i++) {
+                propValue[i] = this.processJson(`${i}`, propValue[i]);
+            }
+        }
+        else if (core.Is.object(propValue)) {
+            for (const key of Object.keys(propValue)) {
+                propValue[key] = this.processJson(key, propValue[key]);
+            }
+        }
+        else if (!this._fullBase64 && core.Is.stringBase64(propValue) && propValue.length > 256) {
+            propValue = "<base64>";
+        }
+        else if (core.Is.string(propValue) &&
+            this._obfuscateProperties.some(op => new RegExp(op).test(propName))) {
+            propValue = "**************";
+        }
+        return propValue;
+    }
+}
+
+/**
+ * Process the JWT mime type.
+ */
+class JwtMimeTypeProcessor {
+    /**
+     * The namespace supported by the processor.
+     */
+    static NAMESPACE = "jwt";
+    /**
+     * Runtime name for the class.
+     */
+    CLASS_NAME = "JwtMimeTypeProcessor";
+    /**
+     * Get the MIME types that this handler can handle.
+     * @returns The MIME types that this handler can handle.
+     */
+    getTypes() {
+        return [web.MimeTypes.Jwt];
+    }
+    /**
+     * Handle content.
+     * @param body The body to process.
+     * @returns The processed body.
+     */
+    async handle(body) {
+        return core.Converter.bytesToUtf8(body);
+    }
 }
 
+exports.JwtMimeTypeProcessor = JwtMimeTypeProcessor;
 exports.LoggingProcessor = LoggingProcessor;
 exports.NodeIdentityProcessor = NodeIdentityProcessor;
-exports.RouteProcessor = RouteProcessor;
+exports.RestRouteProcessor = RestRouteProcessor;
+exports.SocketRouteProcessor = SocketRouteProcessor;
 exports.StaticUserIdentityProcessor = StaticUserIdentityProcessor;