@twin.org/api-processors 0.0.2-next.8 → 0.0.3-next.1

package/dist/esm/index.mjs

@@ -1,519 +0,0 @@
-import { HttpErrorHelper } from '@twin.org/api-models';
-import { Is, NotFoundError, Guards, ComponentFactory, ObjectHelper, Coerce, GeneralError, Converter } from '@twin.org/core';
-import { HttpStatusCode, HeaderTypes, MimeTypes } from '@twin.org/web';
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Process the REST request and hands it on to the route handler.
- */
-class RestRouteProcessor {
-    /**
-     * Runtime name for the class.
-     */
-    CLASS_NAME = "RestRouteProcessor";
-    /**
-     * Include the stack with errors.
-     * @internal
-     */
-    _includeErrorStack;
-    /**
-     * Create a new instance of RouteProcessor.
-     * @param options Options for the processor.
-     */
-    constructor(options) {
-        this._includeErrorStack = options?.config?.includeErrorStack ?? false;
-    }
-    /**
-     * 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 loggingComponentType The logging component type for the request.
-     */
-    async process(request, response, route, requestIdentity, processorState, loggingComponentType) {
-        // 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
-                    };
-                    const restRouteResponse = await route.handler({
-                        ...requestIdentity,
-                        serverRequest: request,
-                        processorState,
-                        loggingComponentType
-                    }, req);
-                    let statusCode = restRouteResponse.statusCode ?? response.statusCode ?? HttpStatusCode.ok;
-                    const headers = restRouteResponse?.headers ?? {};
-                    if (Is.empty(restRouteResponse?.body)) {
-                        // If there is no custom status code and the body is empty
-                        // use the no content response and set the length to 0
-                        headers[HeaderTypes.ContentLength] = "0";
-                        // Only change to no content if the status code is ok
-                        // This could be something like a created status code
-                        // which is successful but has no content
-                        if (statusCode === HttpStatusCode.ok) {
-                            statusCode = HttpStatusCode.noContent;
-                        }
-                    }
-                    else {
-                        // Only set the content type if there is a body
-                        // If there are custom response types for the route then use them
-                        // instead of the default application/json
-                        headers[HeaderTypes.ContentType] =
-                            restRouteResponse?.attachment?.mimeType ??
-                                restRouteResponse.headers?.[HeaderTypes.ContentType] ??
-                                `${MimeTypes.Json}; charset=utf-8`;
-                        // If there are filename or inline options set then add the content disposition
-                        if (Is.stringValue(restRouteResponse?.attachment?.filename) ||
-                            Is.boolean(restRouteResponse?.attachment?.inline)) {
-                            let filename = "";
-                            if (Is.stringValue(restRouteResponse?.attachment?.filename)) {
-                                filename = `; filename="${restRouteResponse?.attachment?.filename}"`;
-                            }
-                            headers[HeaderTypes.ContentDisposition] =
-                                `${restRouteResponse?.attachment?.inline ? "inline" : "attachment"}${filename}`;
-                        }
-                        // If this is a binary response then set the content length
-                        if (Is.uint8Array(restRouteResponse?.body)) {
-                            const contentLength = restRouteResponse.body.length;
-                            headers[HeaderTypes.ContentLength] = contentLength.toString();
-                        }
-                        response.body = restRouteResponse?.body;
-                    }
-                    response.headers = headers;
-                    response.statusCode = statusCode;
-                }
-                catch (err) {
-                    const { error, httpStatusCode } = HttpErrorHelper.processError(err, this._includeErrorStack);
-                    HttpErrorHelper.buildResponse(response, error, httpStatusCode);
-                }
-            }
-        }
-    }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Process the socket request and hands it on to the route handler.
- */
-class SocketRouteProcessor {
-    /**
-     * Runtime name for the class.
-     */
-    CLASS_NAME = "SocketRouteProcessor";
-    /**
-     * Include the stack with errors.
-     * @internal
-     */
-    _includeErrorStack;
-    /**
-     * Create a new instance of SocketRouteProcessor.
-     * @param options Options for the processor.
-     */
-    constructor(options) {
-        this._includeErrorStack = options?.config?.includeErrorStack ?? false;
-    }
-    /**
-     * Process the connected event.
-     * @param request The server request object containing the socket id and other parameters.
-     * @param route The route being requested, if a matching one was found.
-     * @param loggingComponentType The logging component type for the request.
-     * @returns Promise that resolves when the request is processed.
-     */
-    async connected(request, route, loggingComponentType) {
-        if (route?.connected) {
-            try {
-                const socketRequestContext = {
-                    socketId: request.socketId,
-                    serverRequest: request,
-                    processorState: {},
-                    loggingComponentType
-                };
-                await route.connected(socketRequestContext);
-            }
-            catch { }
-        }
-    }
-    /**
-     * Process the disconnected event.
-     * @param request The server request object containing the socket id and other parameters.
-     * @param route The route being requested, if a matching one was found.
-     * @param loggingComponentType The logging component type for the request.
-     * @returns Promise that resolves when the request is processed.
-     */
-    async disconnected(request, route, loggingComponentType) {
-        if (route?.disconnected) {
-            try {
-                const socketRequestContext = {
-                    socketId: request.socketId,
-                    serverRequest: request,
-                    processorState: {},
-                    loggingComponentType
-                };
-                await route.disconnected(socketRequestContext);
-            }
-            catch { }
-        }
-    }
-    /**
-     * 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.
-     * @param loggingComponentType The logging component type for the request.
-     */
-    async process(request, response, route, requestIdentity, processorState, responseEmitter, loggingComponentType) {
-        // 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
-                    };
-                    const socketRequestContext = {
-                        ...requestIdentity,
-                        socketId: request.socketId,
-                        serverRequest: request,
-                        processorState,
-                        loggingComponentType
-                    };
-                    await route.handler(socketRequestContext, 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);
-                }
-            }
-        }
-    }
-}
-
-/**
- * Adds a node identity to the request identity.
- */
-class NodeIdentityProcessor {
-    /**
-     * Runtime name for the class.
-     */
-    CLASS_NAME = "NodeIdentityProcessor";
-    /**
-     * The node identity for request context.
-     * @internal
-     */
-    _nodeIdentity;
-    /**
-     * The service needs to be started when the application is initialized.
-     * @param nodeIdentity The identity of the node.
-     * @param nodeLoggingComponentType The node logging component type.
-     * @returns Nothing.
-     */
-    async start(nodeIdentity, nodeLoggingComponentType) {
-        Guards.string(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
-        this._nodeIdentity = nodeIdentity;
-    }
-    /**
-     * 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) {
-        requestIdentity.nodeIdentity = this._nodeIdentity;
-    }
-}
-
-/**
- * Adds a static user identity to the request context.
- */
-class StaticUserIdentityProcessor {
-    /**
-     * 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 {
-    /**
-     * Runtime name for the class.
-     */
-    CLASS_NAME = "LoggingProcessor";
-    /**
-     * The component for logging the information.
-     * @internal
-     */
-    _logging;
-    /**
-     * Include the body objects when logging the information.
-     * @internal
-     */
-    _includeBody;
-    /**
-     * 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.
-     */
-    constructor(options) {
-        this._logging = ComponentFactory.getIfExists(options?.loggingComponentType ?? "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.
-     * @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) {
-        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._logging?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            ts: Date.now(),
-            message: `===> ${request.method} ${requestUrl}`,
-            data: this._includeBody && isJson
-                ? this.processJson("body", ObjectHelper.clone(request?.body))
-                : undefined
-        });
-    }
-    /**
-     * Post 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 post(request, response, route, requestIdentity, processorState) {
-        let data;
-        if (this._includeBody) {
-            const contentType = response.headers?.[HeaderTypes.ContentType];
-            const isJson = Is.stringValue(contentType)
-                ? contentType.includes(MimeTypes.Json) || contentType.includes(MimeTypes.JsonLd)
-                : false;
-            const contentLength = response.headers?.[HeaderTypes.ContentLength];
-            if (isJson) {
-                data = {
-                    body: this.processJson("body", ObjectHelper.clone(response.body))
-                };
-            }
-            else {
-                const dataParts = {};
-                if (Is.stringValue(contentType)) {
-                    dataParts["Content Type"] = contentType;
-                }
-                if (Is.stringValue(contentLength)) {
-                    dataParts["Content Length"] = contentLength;
-                }
-                if (Object.keys(dataParts).length > 0) {
-                    data = {
-                        headers: dataParts
-                    };
-                }
-            }
-        }
-        const now = process.hrtime.bigint();
-        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._logging?.log({
-            level: Is.number(response.statusCode) && response.statusCode >= HttpStatusCode.badRequest
-                ? "error"
-                : "info",
-            source: this.CLASS_NAME,
-            ts: Date.now(),
-            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 {
-    /**
-     * 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 {
-    /**
-     * 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 { JsonLdMimeTypeProcessor, JwtMimeTypeProcessor, LoggingProcessor, NodeIdentityProcessor, RestRouteProcessor, SocketRouteProcessor, StaticUserIdentityProcessor };

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

@@ -1,28 +0,0 @@
-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 IBaseRouteProcessor {
-    /**
-     * Runtime name for the class.
-     */
-    readonly CLASS_NAME: string;
-    /**
-     * The service needs to be started when the application is initialized.
-     * @param nodeIdentity The identity of the node.
-     * @param nodeLoggingComponentType The node logging component type.
-     * @returns Nothing.
-     */
-    start(nodeIdentity: string, nodeLoggingComponentType?: string): Promise<void>;
-    /**
-     * 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.
-     */
-    pre(request: IHttpServerRequest, response: IHttpResponse, route: IBaseRoute | undefined, requestIdentity: IHttpRequestIdentity, processorState: {
-        [id: string]: unknown;
-    }): Promise<void>;
-}

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

@@ -1,27 +0,0 @@
-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 IBaseRouteProcessor {
-    /**
-     * Runtime name for the class.
-     */
-    readonly CLASS_NAME: string;
-    /**
-     * Create a new instance of StaticIdentityProcessor.
-     * @param options Options for the processor.
-     */
-    constructor(options: IStaticUserIdentityProcessorConstructorOptions);
-    /**
-     * 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.
-     */
-    pre(request: IHttpServerRequest, response: IHttpResponse, route: IBaseRoute | undefined, requestIdentity: IHttpRequestIdentity, processorState: {
-        [id: string]: unknown;
-    }): Promise<void>;
-}

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

@@ -1,9 +0,0 @@
-/**
- * Configuration for the static identity processor.
- */
-export interface IStaticUserIdentityProcessorConfig {
-    /**
-     * The fixed user identity for request context.
-     */
-    userIdentity: string;
-}

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

@@ -1,10 +0,0 @@
-import type { IStaticUserIdentityProcessorConfig } from "./IStaticUserIdentityProcessorConfig";
-/**
- * Options for the StaticUserIdentityProcessor constructor.
- */
-export interface IStaticUserIdentityProcessorConstructorOptions {
-    /**
-     * The configuration for the processor.
-     */
-    config: IStaticUserIdentityProcessorConfig;
-}

package/docs/reference/classes/StaticUserIdentityProcessor.md

@@ -1,85 +0,0 @@
-# Class: StaticUserIdentityProcessor
-
-Adds a static user identity to the request context.
-
-## Implements
-
-- `IBaseRouteProcessor`
-
-## Constructors
-
-### Constructor
-
-> **new StaticUserIdentityProcessor**(`options`): `StaticUserIdentityProcessor`
-
-Create a new instance of StaticIdentityProcessor.
-
-#### Parameters
-
-##### options
-
-[`IStaticUserIdentityProcessorConstructorOptions`](../interfaces/IStaticUserIdentityProcessorConstructorOptions.md)
-
-Options for the processor.
-
-#### Returns
-
-`StaticUserIdentityProcessor`
-
-## Properties
-
-### CLASS\_NAME
-
-> `readonly` **CLASS\_NAME**: `string`
-
-Runtime name for the class.
-
-#### Implementation of
-
-`IBaseRouteProcessor.CLASS_NAME`
-
-## Methods
-
-### pre()
-
-> **pre**(`request`, `response`, `route`, `requestIdentity`, `processorState`): `Promise`\<`void`\>
-
-Pre process the REST request for the specified route.
-
-#### Parameters
-
-##### request
-
-`IHttpServerRequest`
-
-The incoming request.
-
-##### response
-
-`IHttpResponse`
-
-The outgoing response.
-
-##### route
-
-The route to process.
-
-`undefined` | `IBaseRoute`
-
-##### requestIdentity
-
-`IHttpRequestIdentity`
-
-The identity context for the request.
-
-##### processorState
-
-The state handed through the processors.
-
-#### Returns
-
-`Promise`\<`void`\>
-
-#### Implementation of
-
-`IBaseRouteProcessor.pre`

package/docs/reference/interfaces/IStaticUserIdentityProcessorConfig.md

@@ -1,11 +0,0 @@
-# Interface: IStaticUserIdentityProcessorConfig
-
-Configuration for the static identity processor.
-
-## Properties
-
-### userIdentity
-
-> **userIdentity**: `string`
-
-The fixed user identity for request context.