@twin.org/api-processors 0.0.1-next.9 → 0.0.2-next.1

package/dist/esm/index.mjs

@@ -1,5 +1,5 @@
 import { HttpErrorHelper } from '@twin.org/api-models';
-import { Is, NotFoundError, Guards, Coerce } from '@twin.org/core';
+import { Is, NotFoundError, Guards, ObjectHelper, Coerce, GeneralError, Converter } from '@twin.org/core';
 import { HttpStatusCode, HeaderTypes, MimeTypes } from '@twin.org/web';
 import { LoggingConnectorFactory } from '@twin.org/logging-models';
 
@@ -8,11 +8,15 @@ import { LoggingConnectorFactory } from '@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
@@ -21,8 +25,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;
@@ -110,42 +112,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) {
-        Guards.object(this.CLASS_NAME, "options", options);
-        Guards.object(this.CLASS_NAME, "options.config", options.config);
-        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 (!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 (Is.empty(response.statusCode)) {
+            if (Is.empty(route)) {
+                HttpErrorHelper.buildResponse(response, {
+                    name: NotFoundError.CLASS_NAME,
+                    message: `${this.CLASS_NAME}.routeNotFound`,
+                    properties: {
+                        notFoundId: request.url
+                    }
+                }, 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 ?? HttpStatusCode.ok;
+                        await responseEmitter(topic, response);
+                    });
+                }
+                catch (err) {
+                    const { error, httpStatusCode } = HttpErrorHelper.processError(err, this._includeErrorStack);
+                    HttpErrorHelper.buildResponse(response, error, httpStatusCode);
+                }
+            }
         }
     }
 }
@@ -154,6 +192,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.
      */
@@ -186,10 +228,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) {
+        Guards.object(this.CLASS_NAME, "options", options);
+        Guards.object(this.CLASS_NAME, "options.config", options.config);
+        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 (!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.
      */
@@ -205,15 +293,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 = 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.
@@ -226,12 +323,28 @@ class LoggingProcessor {
     async pre(request, response, route, requestIdentity, processorState) {
         const now = process.hrtime.bigint();
         processorState.requestStart = now;
+        const contentType = request.headers?.[HeaderTypes.ContentType];
+        const isJson = Is.stringValue(contentType)
+            ? contentType.includes(MimeTypes.Json) || contentType.includes(MimeTypes.JsonLd)
+            : false;
+        let requestUrl = "";
+        if (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", ObjectHelper.clone(request?.body))
+                : undefined
         });
     }
     /**
@@ -246,11 +359,13 @@ class LoggingProcessor {
         let data;
         if (this._includeBody) {
             const contentType = response.headers?.[HeaderTypes.ContentType];
-            const isJson = contentType?.includes(`${MimeTypes.Json}; charset=utf-8`);
+            const isJson = Is.stringValue(contentType)
+                ? contentType.includes(MimeTypes.Json) || contentType.includes(MimeTypes.JsonLd)
+                : false;
             const contentLength = response.headers?.[HeaderTypes.ContentLength];
             if (isJson) {
                 data = {
-                    body: response.body
+                    body: this.processJson("body", ObjectHelper.clone(response.body))
                 };
             }
             else {
@@ -272,16 +387,114 @@ class LoggingProcessor {
         const start = Coerce.bigint(processorState.requestStart) ?? now;
         const elapsed = now - start;
         const elapsedMicroSeconds = Math.floor(Number(elapsed) / 1000);
+        let requestUrl = "";
+        if (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: Is.number(response.statusCode) && response.statusCode >= 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 (Is.array(propValue)) {
+            for (let i = 0; i < propValue.length; i++) {
+                propValue[i] = this.processJson(`${i}`, propValue[i]);
+            }
+        }
+        else if (Is.object(propValue)) {
+            for (const key of Object.keys(propValue)) {
+                propValue[key] = this.processJson(key, propValue[key]);
+            }
+        }
+        else if (!this._fullBase64 && Is.stringBase64(propValue) && propValue.length > 256) {
+            propValue = "<base64>";
+        }
+        else if (Is.string(propValue) &&
+            this._obfuscateProperties.some(op => new RegExp(op).test(propName))) {
+            propValue = "**************";
+        }
+        return propValue;
+    }
+}
+
+/**
+ * Process the JSON-LD mime type.
+ */
+class JsonLdMimeTypeProcessor {
+    /**
+     * The namespace supported by the processor.
+     */
+    static NAMESPACE = "json-ld";
+    /**
+     * Runtime name for the class.
+     */
+    CLASS_NAME = "JsonLdMimeTypeProcessor";
+    /**
+     * Get the MIME types that this handler can handle.
+     * @returns The MIME types that this handler can handle.
+     */
+    getTypes() {
+        return [MimeTypes.JsonLd];
+    }
+    /**
+     * Handle content.
+     * @param body The body to process.
+     * @returns The processed body.
+     */
+    async handle(body) {
+        const json = ObjectHelper.fromBytes(body);
+        if (Is.empty(json) || Is.empty(json["@context"])) {
+            throw new GeneralError(this.CLASS_NAME, "invalidJsonLd");
+        }
+        return json;
+    }
+}
+
+/**
+ * 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 [MimeTypes.Jwt];
+    }
+    /**
+     * Handle content.
+     * @param body The body to process.
+     * @returns The processed body.
+     */
+    async handle(body) {
+        return Converter.bytesToUtf8(body);
+    }
 }
 
-export { LoggingProcessor, NodeIdentityProcessor, RouteProcessor, StaticUserIdentityProcessor };
+export { JsonLdMimeTypeProcessor, JwtMimeTypeProcessor, LoggingProcessor, NodeIdentityProcessor, RestRouteProcessor, SocketRouteProcessor, StaticUserIdentityProcessor };

package/dist/types/data/{routeProcessor.d.ts → restRouteProcessor.d.ts}

@@ -1,9 +1,13 @@
-import { type IHttpRequestIdentity, type IHttpResponse, type IHttpRestRouteProcessor, type IHttpServerRequest, type IRestRoute } from "@twin.org/api-models";
-import type { IRouteProcessorConfig } from "../models/IRouteProcessorConfig";
+import { type IHttpRequestIdentity, type IHttpResponse, type IRestRouteProcessor, type IHttpServerRequest, type IRestRoute } from "@twin.org/api-models";
+import type { IRestRouteProcessorConstructorOptions } from "../models/IRestRouteProcessorConstructorOptions";
 /**
  * Process the REST request and hands it on to the route handler.
  */
-export declare class RouteProcessor implements IHttpRestRouteProcessor {
+export declare class RestRouteProcessor implements IRestRouteProcessor {
+    /**
+     * The namespace supported by the processor.
+     */
+    static readonly NAMESPACE: string;
     /**
      * Runtime name for the class.
      */
@@ -11,12 +15,8 @@ export declare class RouteProcessor implements IHttpRestRouteProcessor {
     /**
      * 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?: {
-        config?: IRouteProcessorConfig;
-    });
+    constructor(options?: IRestRouteProcessorConstructorOptions);
     /**
      * Process the REST request for the specified route.
      * @param request The incoming request.

package/dist/types/data/socketRouteProcessor.d.ts

@@ -0,0 +1,32 @@
+import { type IHttpRequestIdentity, type IHttpResponse, type IHttpServerRequest, type ISocketRoute, type ISocketRouteProcessor } from "@twin.org/api-models";
+import type { ISocketRouteProcessorConstructorOptions } from "../models/ISocketRouteProcessorConstructorOptions";
+/**
+ * Process the socket request and hands it on to the route handler.
+ */
+export declare class SocketRouteProcessor implements ISocketRouteProcessor {
+    /**
+     * The namespace supported by the processor.
+     */
+    static readonly NAMESPACE: string;
+    /**
+     * Runtime name for the class.
+     */
+    readonly CLASS_NAME: string;
+    /**
+     * Create a new instance of SocketRouteProcessor.
+     * @param options Options for the processor.
+     */
+    constructor(options?: ISocketRouteProcessorConstructorOptions);
+    /**
+     * 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.
+     */
+    process(request: IHttpServerRequest, response: IHttpResponse, route: ISocketRoute | undefined, requestIdentity: IHttpRequestIdentity, processorState: {
+        [id: string]: unknown;
+    }, responseEmitter: (topic: string, response: IHttpResponse) => Promise<void>): Promise<void>;
+}

package/dist/types/identity/nodeIdentityProcessor.d.ts

@@ -1,8 +1,12 @@
-import type { IHttpRequestIdentity, IHttpResponse, IHttpRestRouteProcessor, IHttpServerRequest, IRestRoute } from "@twin.org/api-models";
+import type { IBaseRoute, IBaseRouteProcessor, IHttpRequestIdentity, IHttpResponse, IHttpServerRequest } from "@twin.org/api-models";
 /**
  * Adds a node identity to the request identity.
  */
-export declare class NodeIdentityProcessor implements IHttpRestRouteProcessor {
+export declare class NodeIdentityProcessor implements IBaseRouteProcessor {
+    /**
+     * The namespace supported by the processor.
+     */
+    static readonly NAMESPACE: string;
     /**
      * Runtime name for the class.
      */
@@ -22,7 +26,7 @@ export declare class NodeIdentityProcessor implements IHttpRestRouteProcessor {
      * @param requestIdentity The identity context for the request.
      * @param processorState The state handed through the processors.
      */
-    pre(request: IHttpServerRequest, response: IHttpResponse, route: IRestRoute | undefined, requestIdentity: IHttpRequestIdentity, processorState: {
+    pre(request: IHttpServerRequest, response: IHttpResponse, route: IBaseRoute | undefined, requestIdentity: IHttpRequestIdentity, processorState: {
         [id: string]: unknown;
     }): Promise<void>;
 }

package/dist/types/identity/staticUserIdentityProcessor.d.ts

@@ -1,9 +1,13 @@
-import type { IHttpRequestIdentity, IHttpResponse, IHttpRestRouteProcessor, IHttpServerRequest, IRestRoute } from "@twin.org/api-models";
-import type { IStaticUserIdentityProcessorConfig } from "../models/IStaticUserIdentityProcessorConfig";
+import type { IBaseRoute, IBaseRouteProcessor, IHttpRequestIdentity, IHttpResponse, IHttpServerRequest } from "@twin.org/api-models";
+import type { IStaticUserIdentityProcessorConstructorOptions } from "../models/IStaticUserIdentityProcessorConstructorOptions";
 /**
  * Adds a static user identity to the request context.
  */
-export declare class StaticUserIdentityProcessor implements IHttpRestRouteProcessor {
+export declare class StaticUserIdentityProcessor implements IBaseRouteProcessor {
+    /**
+     * The namespace supported by the processor.
+     */
+    static readonly NAMESPACE: string;
     /**
      * Runtime name for the class.
      */
@@ -11,12 +15,8 @@ export declare class StaticUserIdentityProcessor implements IHttpRestRouteProces
     /**
      * Create a new instance of StaticIdentityProcessor.
      * @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: {
-        config: IStaticUserIdentityProcessorConfig;
-    });
+    constructor(options: IStaticUserIdentityProcessorConstructorOptions);
     /**
      * Pre process the REST request for the specified route.
      * @param request The incoming request.
@@ -25,7 +25,7 @@ export declare class StaticUserIdentityProcessor implements IHttpRestRouteProces
      * @param requestIdentity The identity context for the request.
      * @param processorState The state handed through the processors.
      */
-    pre(request: IHttpServerRequest, response: IHttpResponse, route: IRestRoute | undefined, requestIdentity: IHttpRequestIdentity, processorState: {
+    pre(request: IHttpServerRequest, response: IHttpResponse, route: IBaseRoute | undefined, requestIdentity: IHttpRequestIdentity, processorState: {
         [id: string]: unknown;
     }): Promise<void>;
 }

package/dist/types/index.d.ts

@@ -1,8 +1,14 @@
-export * from "./data/routeProcessor";
-export * from "./identity/staticUserIdentityProcessor";
+export * from "./data/restRouteProcessor";
+export * from "./data/socketRouteProcessor";
 export * from "./identity/nodeIdentityProcessor";
+export * from "./identity/staticUserIdentityProcessor";
 export * from "./logging/loggingProcessor";
-export * from "./models/IRequestLoggingProcessorConfig";
-export * from "./models/IResponseLoggingProcessorConfig";
+export * from "./mimeType/jsonLdMimeTypeProcessor";
+export * from "./mimeType/jwtMimeTypeProcessor";
+export * from "./models/ILoggingProcessorConfig";
+export * from "./models/ILoggingProcessorConstructorOptions";
+export * from "./models/IRestRouteProcessorConstructorOptions";
 export * from "./models/IRouteProcessorConfig";
+export * from "./models/ISocketRouteProcessorConstructorOptions";
 export * from "./models/IStaticUserIdentityProcessorConfig";
+export * from "./models/IStaticUserIdentityProcessorConstructorOptions";

package/dist/types/logging/loggingProcessor.d.ts

@@ -1,24 +1,22 @@
-import type { IHttpRequestIdentity, IHttpResponse, IHttpRestRouteProcessor, IHttpServerRequest, IRestRoute } from "@twin.org/api-models";
-import type { IRequestLoggingProcessorConfig } from "../models/IRequestLoggingProcessorConfig";
+import type { IBaseRoute, IBaseRouteProcessor, IHttpRequestIdentity, IHttpResponse, IHttpServerRequest } from "@twin.org/api-models";
+import type { ILoggingProcessorConstructorOptions } from "../models/ILoggingProcessorConstructorOptions";
 /**
  * Process the REST request and log its information.
  */
-export declare class LoggingProcessor implements IHttpRestRouteProcessor {
+export declare class LoggingProcessor implements IBaseRouteProcessor {
+    /**
+     * The namespace supported by the processor.
+     */
+    static readonly NAMESPACE: string;
     /**
      * Runtime name for the class.
      */
     readonly CLASS_NAME: string;
     /**
-     * Create a new instance of RequestLoggingProcessor.
+     * 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?: {
-        loggingConnectorType?: string;
-        config?: IRequestLoggingProcessorConfig;
-    });
+    constructor(options?: ILoggingProcessorConstructorOptions);
     /**
      * Pre process the REST request for the specified route.
      * @param request The incoming request.
@@ -27,7 +25,7 @@ export declare class LoggingProcessor implements IHttpRestRouteProcessor {
      * @param requestIdentity The identity context for the request.
      * @param processorState The state handed through the processors.
      */
-    pre(request: IHttpServerRequest, response: IHttpResponse, route: IRestRoute | undefined, requestIdentity: IHttpRequestIdentity, processorState: {
+    pre(request: IHttpServerRequest, response: IHttpResponse, route: IBaseRoute | undefined, requestIdentity: IHttpRequestIdentity, processorState: {
         [id: string]: unknown;
     }): Promise<void>;
     /**
@@ -38,7 +36,7 @@ export declare class LoggingProcessor implements IHttpRestRouteProcessor {
      * @param requestIdentity The identity context for the request.
      * @param processorState The state handed through the processors.
      */
-    post(request: IHttpServerRequest, response: IHttpResponse, route: IRestRoute | undefined, requestIdentity: IHttpRequestIdentity, processorState: {
+    post(request: IHttpServerRequest, response: IHttpResponse, route: IBaseRoute | undefined, requestIdentity: IHttpRequestIdentity, processorState: {
         [id: string]: unknown;
     }): Promise<void>;
 }

package/dist/types/mimeType/jsonLdMimeTypeProcessor.d.ts

@@ -0,0 +1,25 @@
+import type { IMimeTypeProcessor } from "@twin.org/api-models";
+/**
+ * Process the JSON-LD mime type.
+ */
+export declare class JsonLdMimeTypeProcessor implements IMimeTypeProcessor {
+    /**
+     * The namespace supported by the processor.
+     */
+    static readonly NAMESPACE: string;
+    /**
+     * Runtime name for the class.
+     */
+    readonly CLASS_NAME: string;
+    /**
+     * Get the MIME types that this handler can handle.
+     * @returns The MIME types that this handler can handle.
+     */
+    getTypes(): string[];
+    /**
+     * Handle content.
+     * @param body The body to process.
+     * @returns The processed body.
+     */
+    handle(body: Uint8Array): Promise<unknown>;
+}

package/dist/types/mimeType/jwtMimeTypeProcessor.d.ts

@@ -0,0 +1,25 @@
+import type { IMimeTypeProcessor } from "@twin.org/api-models";
+/**
+ * Process the JWT mime type.
+ */
+export declare class JwtMimeTypeProcessor implements IMimeTypeProcessor {
+    /**
+     * The namespace supported by the processor.
+     */
+    static readonly NAMESPACE: string;
+    /**
+     * Runtime name for the class.
+     */
+    readonly CLASS_NAME: string;
+    /**
+     * Get the MIME types that this handler can handle.
+     * @returns The MIME types that this handler can handle.
+     */
+    getTypes(): string[];
+    /**
+     * Handle content.
+     * @param body The body to process.
+     * @returns The processed body.
+     */
+    handle(body: Uint8Array): Promise<unknown>;
+}

package/dist/types/models/ILoggingProcessorConfig.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Configuration for the request logging processor.
+ */
+export interface ILoggingProcessorConfig {
+    /**
+     * Include the body objects when logging the information.
+     */
+    includeBody?: boolean;
+    /**
+     * Show the full base64 content for data, default to abbreviate.
+     */
+    fullBase64?: boolean;
+    /**
+     * List of property names to obfuscate, can be regex, defaults to "password".
+     */
+    obfuscateProperties?: string[];
+}

package/dist/types/models/ILoggingProcessorConstructorOptions.d.ts

@@ -0,0 +1,15 @@
+import type { ILoggingProcessorConfig } from "./ILoggingProcessorConfig";
+/**
+ * Options for the LoggingProcessor constructor.
+ */
+export interface ILoggingProcessorConstructorOptions {
+    /**
+     * The type for the logging connector.
+     * @default logging
+     */
+    loggingConnectorType?: string;
+    /**
+     *
+     */
+    config?: ILoggingProcessorConfig;
+}