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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@twin.org/api-processors",
-	"version": "0.0.2-next.8",
+	"version": "0.0.3-next.1",
 	"description": "Route processors for use with API servers",
 	"repository": {
 		"type": "git",
@@ -14,27 +14,38 @@
 		"node": ">=20.0.0"
 	},
 	"dependencies": {
-		"@twin.org/api-models": "0.0.2-next.8",
+		"@twin.org/api-models": "0.0.3-next.1",
+		"@twin.org/context": "next",
 		"@twin.org/core": "next",
 		"@twin.org/logging-models": "next",
 		"@twin.org/nameof": "next",
 		"@twin.org/web": "next"
 	},
-	"main": "./dist/cjs/index.cjs",
-	"module": "./dist/esm/index.mjs",
+	"main": "./dist/es/index.js",
 	"types": "./dist/types/index.d.ts",
 	"exports": {
 		".": {
 			"types": "./dist/types/index.d.ts",
-			"require": "./dist/cjs/index.cjs",
-			"import": "./dist/esm/index.mjs"
+			"import": "./dist/es/index.js",
+			"default": "./dist/es/index.js"
 		}
 	},
 	"files": [
-		"dist/cjs",
-		"dist/esm",
+		"dist/es",
 		"dist/types",
 		"locales",
 		"docs"
-	]
+	],
+	"keywords": [
+		"twin",
+		"trade",
+		"iota",
+		"framework",
+		"blockchain",
+		"api"
+	],
+	"bugs": {
+		"url": "git+https://github.com/twinfoundation/api/issues"
+	},
+	"homepage": "https://twindev.org"
 }

package/dist/cjs/index.cjs

@@ -1,527 +0,0 @@
-'use strict';
-
-var apiModels = require('@twin.org/api-models');
-var core = require('@twin.org/core');
-var web = require('@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 (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
-                    };
-                    const restRouteResponse = await route.handler({
-                        ...requestIdentity,
-                        serverRequest: request,
-                        processorState,
-                        loggingComponentType
-                    }, req);
-                    let statusCode = restRouteResponse.statusCode ?? response.statusCode ?? web.HttpStatusCode.ok;
-                    const headers = restRouteResponse?.headers ?? {};
-                    if (core.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[web.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 === web.HttpStatusCode.ok) {
-                            statusCode = web.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[web.HeaderTypes.ContentType] =
-                            restRouteResponse?.attachment?.mimeType ??
-                                restRouteResponse.headers?.[web.HeaderTypes.ContentType] ??
-                                `${web.MimeTypes.Json}; charset=utf-8`;
-                        // If there are filename or inline options set then add the content disposition
-                        if (core.Is.stringValue(restRouteResponse?.attachment?.filename) ||
-                            core.Is.boolean(restRouteResponse?.attachment?.inline)) {
-                            let filename = "";
-                            if (core.Is.stringValue(restRouteResponse?.attachment?.filename)) {
-                                filename = `; filename="${restRouteResponse?.attachment?.filename}"`;
-                            }
-                            headers[web.HeaderTypes.ContentDisposition] =
-                                `${restRouteResponse?.attachment?.inline ? "inline" : "attachment"}${filename}`;
-                        }
-                        // If this is a binary response then set the content length
-                        if (core.Is.uint8Array(restRouteResponse?.body)) {
-                            const contentLength = restRouteResponse.body.length;
-                            headers[web.HeaderTypes.ContentLength] = contentLength.toString();
-                        }
-                        response.body = restRouteResponse?.body;
-                    }
-                    response.headers = headers;
-                    response.statusCode = statusCode;
-                }
-                catch (err) {
-                    const { error, httpStatusCode } = apiModels.HttpErrorHelper.processError(err, this._includeErrorStack);
-                    apiModels.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 (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
-                    };
-                    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 ?? web.HttpStatusCode.ok;
-                        await responseEmitter(topic, response);
-                    });
-                }
-                catch (err) {
-                    const { error, httpStatusCode } = apiModels.HttpErrorHelper.processError(err, this._includeErrorStack);
-                    apiModels.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) {
-        core.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) {
-        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 {
-    /**
-     * 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 = core.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?.[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._logging?.log({
-            level: "info",
-            source: this.CLASS_NAME,
-            ts: Date.now(),
-            message: `===> ${request.method} ${requestUrl}`,
-            data: this._includeBody && isJson
-                ? this.processJson("body", core.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?.[web.HeaderTypes.ContentType];
-            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: this.processJson("body", core.ObjectHelper.clone(response.body))
-                };
-            }
-            else {
-                const dataParts = {};
-                if (core.Is.stringValue(contentType)) {
-                    dataParts["Content Type"] = contentType;
-                }
-                if (core.Is.stringValue(contentLength)) {
-                    dataParts["Content Length"] = contentLength;
-                }
-                if (Object.keys(dataParts).length > 0) {
-                    data = {
-                        headers: dataParts
-                    };
-                }
-            }
-        }
-        const now = process.hrtime.bigint();
-        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._logging?.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} ${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 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 [web.MimeTypes.JsonLd];
-    }
-    /**
-     * Handle content.
-     * @param body The body to process.
-     * @returns The processed body.
-     */
-    async handle(body) {
-        const json = core.ObjectHelper.fromBytes(body);
-        if (core.Is.empty(json) || core.Is.empty(json["@context"])) {
-            throw new core.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 [web.MimeTypes.Jwt];
-    }
-    /**
-     * Handle content.
-     * @param body The body to process.
-     * @returns The processed body.
-     */
-    async handle(body) {
-        return core.Converter.bytesToUtf8(body);
-    }
-}
-
-exports.JsonLdMimeTypeProcessor = JsonLdMimeTypeProcessor;
-exports.JwtMimeTypeProcessor = JwtMimeTypeProcessor;
-exports.LoggingProcessor = LoggingProcessor;
-exports.NodeIdentityProcessor = NodeIdentityProcessor;
-exports.RestRouteProcessor = RestRouteProcessor;
-exports.SocketRouteProcessor = SocketRouteProcessor;
-exports.StaticUserIdentityProcessor = StaticUserIdentityProcessor;