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

package/dist/cjs/index.cjs

@@ -3,10 +3,24 @@
 var FastifyCompress = require('@fastify/compress');
 var FastifyCors = require('@fastify/cors');
 var apiModels = require('@twin.org/api-models');
+var apiProcessors = require('@twin.org/api-processors');
 var core = require('@twin.org/core');
 var loggingModels = require('@twin.org/logging-models');
 var web = require('@twin.org/web');
 var Fastify = require('fastify');
+var fp = require('fastify-plugin');
+var socket_io = require('socket.io');
+
+// This is a clone of fastify-socket.io which runs with recent fastify versions.
+const fastifySocketIO = fp(async (fastify, opts) => {
+    const ioServer = new socket_io.Server(fastify.server, opts);
+    fastify.decorate("io", ioServer);
+    fastify.addHook("preClose", done => {
+        ioServer.disconnectSockets();
+        ioServer.close();
+        done();
+    });
+}, { fastify: ">=5.x.x", name: "socket.io" });
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
@@ -48,23 +62,49 @@ class FastifyWebServer {
      * @internal
      */
     _fastify;
+    /**
+     * The options for the socket server.
+     * @internal
+     */
+    _socketConfig;
     /**
      * Whether the server has been started.
      * @internal
      */
     _started;
+    /**
+     * The mime type processors.
+     * @internal
+     */
+    _mimeTypeProcessors;
+    /**
+     * Include the stack with errors.
+     * @internal
+     */
+    _includeErrorStack;
     /**
      * Create a new instance of FastifyWebServer.
      * @param options The options for the server.
-     * @param options.loggingConnectorType The type of the logging connector to use, if undefined, no logging will happen.
-     * @param options.config Additional options for the Fastify server.
      */
     constructor(options) {
         this._loggingConnector = core.Is.stringValue(options?.loggingConnectorType)
             ? loggingModels.LoggingConnectorFactory.get(options.loggingConnectorType)
             : undefined;
-        this._fastify = Fastify({ maxParamLength: 2000, ...options?.config });
+        this._fastify = Fastify({
+            maxParamLength: 2000,
+            ...options?.config?.web
+        });
+        this._socketConfig = {
+            path: "/socket",
+            ...options?.config?.socket
+        };
         this._started = false;
+        this._mimeTypeProcessors = options?.mimeTypeProcessors ?? [];
+        const hasJsonLd = this._mimeTypeProcessors.find(processor => processor.CLASS_NAME === "json-ld");
+        if (!hasJsonLd) {
+            this._mimeTypeProcessors.push(new apiProcessors.JsonLdMimeTypeProcessor());
+        }
+        this._includeErrorStack = options?.config?.includeErrorStack ?? false;
     }
     /**
      * Get the web server instance.
@@ -75,14 +115,19 @@ class FastifyWebServer {
     }
     /**
      * Build the server.
-     * @param restRouteProcessors The hooks to process the incoming requests.
+     * @param restRouteProcessors The processors for incoming requests over REST.
      * @param restRoutes The REST routes.
+     * @param socketRouteProcessors The processors for incoming requests over Sockets.
+     * @param socketRoutes The socket routes.
      * @param options Options for building the server.
      * @returns Nothing.
      */
-    async build(restRouteProcessors, restRoutes, options) {
-        if (!core.Is.arrayValue(restRouteProcessors)) {
-            throw new core.GeneralError(this.CLASS_NAME, "noProcessors");
+    async build(restRouteProcessors, restRoutes, socketRouteProcessors, socketRoutes, options) {
+        if (core.Is.arrayValue(restRoutes) && !core.Is.arrayValue(restRouteProcessors)) {
+            throw new core.GeneralError(this.CLASS_NAME, "noRestProcessors");
+        }
+        if (core.Is.arrayValue(socketRoutes) && !core.Is.arrayValue(socketRouteProcessors)) {
+            throw new core.GeneralError(this.CLASS_NAME, "noSocketProcessors");
         }
         await this._loggingConnector?.log({
             level: "info",
@@ -92,8 +137,25 @@ class FastifyWebServer {
         });
         this._options = options;
         await this._fastify.register(FastifyCompress);
+        if (core.Is.arrayValue(socketRoutes)) {
+            await this._fastify.register(fastifySocketIO, this._socketConfig);
+        }
+        if (core.Is.arrayValue(this._mimeTypeProcessors)) {
+            for (const contentTypeHandler of this._mimeTypeProcessors) {
+                this._fastify.addContentTypeParser(contentTypeHandler.getTypes(), { parseAs: "buffer" }, (request, body, done) => {
+                    // Fastify does not handle this method correctly if it is async
+                    // so we have to use the callback method
+                    contentTypeHandler
+                        .handle(body)
+                        // eslint-disable-next-line promise/prefer-await-to-then, promise/no-callback-in-promise
+                        .then(processed => done(null, processed))
+                        // eslint-disable-next-line promise/prefer-await-to-then, promise/no-callback-in-promise
+                        .catch(err => done(core.BaseError.fromError(err)));
+                });
+            }
+        }
         await this.initCors(options);
-        this._fastify.setNotFoundHandler({}, async (request, reply) => this.handleRequest(restRouteProcessors, request, reply));
+        this._fastify.setNotFoundHandler({}, async (request, reply) => this.handleRequestRest(restRouteProcessors ?? [], request, reply));
         this._fastify.setErrorHandler(async (error, request, reply) => {
             // If code property is set this is a fastify error
             // otherwise it's from our framework
@@ -123,22 +185,8 @@ class FastifyWebServer {
                 error: err
             });
         });
-        // Add the routes to the server.
-        for (const restRoute of restRoutes) {
-            let path = core.StringHelper.trimTrailingSlashes(restRoute.path);
-            if (!path.startsWith("/")) {
-                path = `/${path}`;
-            }
-            await this._loggingConnector?.log({
-                level: "info",
-                ts: Date.now(),
-                source: this.CLASS_NAME,
-                message: `${FastifyWebServer._CLASS_NAME_CAMEL_CASE}.restRouteAdded`,
-                data: { route: path, method: restRoute.method }
-            });
-            const method = restRoute.method.toLowerCase();
-            this._fastify[method](path, async (request, reply) => this.handleRequest(restRouteProcessors, request, reply, restRoute));
-        }
+        await this.addRoutesRest(restRouteProcessors, restRoutes);
+        await this.addRoutesSocket(socketRouteProcessors, socketRoutes);
     }
     /**
      * Start the server.
@@ -203,14 +251,109 @@ class FastifyWebServer {
         }
     }
     /**
-     * Handle the incoming request.
+     * Add the REST routes to the server.
+     * @param restRouteProcessors The processors for the incoming requests.
+     * @param restRoutes The REST routes to add.
+     * @internal
+     */
+    async addRoutesRest(restRouteProcessors, restRoutes) {
+        if (core.Is.arrayValue(restRouteProcessors) && core.Is.arrayValue(restRoutes)) {
+            for (const restRoute of restRoutes) {
+                let path = core.StringHelper.trimTrailingSlashes(restRoute.path);
+                if (!path.startsWith("/")) {
+                    path = `/${path}`;
+                }
+                await this._loggingConnector?.log({
+                    level: "info",
+                    ts: Date.now(),
+                    source: this.CLASS_NAME,
+                    message: `${FastifyWebServer._CLASS_NAME_CAMEL_CASE}.restRouteAdded`,
+                    data: { route: path, method: restRoute.method }
+                });
+                const method = restRoute.method.toLowerCase();
+                this._fastify[method](path, async (request, reply) => this.handleRequestRest(restRouteProcessors, request, reply, restRoute));
+            }
+        }
+    }
+    /**
+     * Add the socket routes to the server.
+     * @param socketRouteProcessors The processors for the incoming requests.
+     * @param socketRoutes The socket routes to add.
+     * @internal
+     */
+    async addRoutesSocket(socketRouteProcessors, socketRoutes) {
+        if (core.Is.arrayValue(socketRouteProcessors) && core.Is.arrayValue(socketRoutes)) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const io = this._fastify.io;
+            for (const socketRoute of socketRoutes) {
+                const path = core.StringHelper.trimLeadingSlashes(core.StringHelper.trimTrailingSlashes(socketRoute.path));
+                const pathParts = path.split("/");
+                await this._loggingConnector?.log({
+                    level: "info",
+                    ts: Date.now(),
+                    source: this.CLASS_NAME,
+                    message: `${FastifyWebServer._CLASS_NAME_CAMEL_CASE}.socketRouteAdded`,
+                    data: { route: `/${path}` }
+                });
+                const socketNamespace = io.of(`/${pathParts[0]}`);
+                const topic = pathParts.slice(1).join("/");
+                socketNamespace.on("connection", async (socket) => {
+                    const httpServerRequest = {
+                        method: web.HttpMethod.GET,
+                        url: socket.handshake.url,
+                        query: socket.handshake.query,
+                        headers: socket.handshake.headers
+                    };
+                    // Pass the connected information on to any processors
+                    try {
+                        const processorState = {
+                            socketId: socket.id
+                        };
+                        for (const socketRouteProcessor of socketRouteProcessors) {
+                            if (core.Is.function(socketRouteProcessor.connected)) {
+                                await socketRouteProcessor.connected(httpServerRequest, socketRoute, processorState);
+                            }
+                        }
+                    }
+                    catch (err) {
+                        const { error, httpStatusCode } = apiModels.HttpErrorHelper.processError(err, this._includeErrorStack);
+                        const response = {};
+                        apiModels.HttpErrorHelper.buildResponse(response, error, httpStatusCode);
+                        socket.emit(topic, response);
+                    }
+                    socket.on("disconnect", async () => {
+                        try {
+                            const processorState = {
+                                socketId: socket.id
+                            };
+                            // The socket disconnected so notify any processors
+                            for (const socketRouteProcessor of socketRouteProcessors) {
+                                if (core.Is.function(socketRouteProcessor.disconnected)) {
+                                    await socketRouteProcessor.disconnected(httpServerRequest, socketRoute, processorState);
+                                }
+                            }
+                        }
+                        catch {
+                            // If something fails on a disconnect there is not much we can do with it
+                        }
+                    });
+                    // Handle any incoming messages
+                    socket.on(topic, async (data) => {
+                        await this.handleRequestSocket(socketRouteProcessors, socketRoute, socket, `/${pathParts.join("/")}`, topic, data);
+                    });
+                });
+            }
+        }
+    }
+    /**
+     * Handle the incoming REST request.
      * @param restRouteProcessors The hooks to process the incoming requests.
      * @param request The incoming request.
      * @param reply The outgoing response.
      * @param restRoute The REST route to handle.
      * @internal
      */
-    async handleRequest(restRouteProcessors, request, reply, restRoute) {
+    async handleRequestRest(restRouteProcessors, request, reply, restRoute) {
         const httpServerRequest = {
             method: request.method.toUpperCase(),
             url: `${request.protocol}://${request.hostname}${request.url}`,
@@ -222,21 +365,7 @@ class FastifyWebServer {
         const httpResponse = {};
         const httpRequestIdentity = {};
         const processorState = {};
-        for (const restRouteProcessor of restRouteProcessors) {
-            if (core.Is.function(restRouteProcessor.pre)) {
-                await restRouteProcessor.pre(httpServerRequest, httpResponse, restRoute, httpRequestIdentity, processorState);
-            }
-        }
-        for (const restRouteProcessor of restRouteProcessors) {
-            if (core.Is.function(restRouteProcessor.process)) {
-                await restRouteProcessor.process(httpServerRequest, httpResponse, restRoute, httpRequestIdentity, processorState);
-            }
-        }
-        for (const restRouteProcessor of restRouteProcessors) {
-            if (core.Is.function(restRouteProcessor.post)) {
-                await restRouteProcessor.post(httpServerRequest, httpResponse, restRoute, httpRequestIdentity, processorState);
-            }
-        }
+        await this.runProcessorsRest(restRouteProcessors, restRoute, httpServerRequest, httpResponse, httpRequestIdentity, processorState);
         if (!core.Is.empty(httpResponse.headers)) {
             for (const header of Object.keys(httpResponse.headers)) {
                 reply.header(header, httpResponse.headers[header]);
@@ -246,6 +375,135 @@ class FastifyWebServer {
             .status((httpResponse.statusCode ?? web.HttpStatusCode.ok))
             .send(httpResponse.body);
     }
+    /**
+     * Run the REST processors for the route.
+     * @param restRouteProcessors The processors to run.
+     * @param restRoute The route to process.
+     * @param httpServerRequest The incoming request.
+     * @param httpResponse The outgoing response.
+     * @param httpRequestIdentity The identity context for the request.
+     * @internal
+     */
+    async runProcessorsRest(restRouteProcessors, restRoute, httpServerRequest, httpResponse, httpRequestIdentity, processorState) {
+        try {
+            for (const routeProcessor of restRouteProcessors) {
+                if (core.Is.function(routeProcessor.pre)) {
+                    await routeProcessor.pre(httpServerRequest, httpResponse, restRoute, httpRequestIdentity, processorState);
+                }
+            }
+            for (const routeProcessor of restRouteProcessors) {
+                if (core.Is.function(routeProcessor.process)) {
+                    await routeProcessor.process(httpServerRequest, httpResponse, restRoute, httpRequestIdentity, processorState);
+                }
+            }
+            for (const routeProcessor of restRouteProcessors) {
+                if (core.Is.function(routeProcessor.post)) {
+                    await routeProcessor.post(httpServerRequest, httpResponse, restRoute, httpRequestIdentity, processorState);
+                }
+            }
+        }
+        catch (err) {
+            const { error, httpStatusCode } = apiModels.HttpErrorHelper.processError(err, this._includeErrorStack);
+            apiModels.HttpErrorHelper.buildResponse(httpResponse, error, httpStatusCode);
+        }
+    }
+    /**
+     * Handle the incoming socket request.
+     * @param socketRouteProcessors The hooks to process the incoming requests.
+     * @param socketRoute The socket route to handle.
+     * @param socket The socket to handle.
+     * @param fullPath The full path of the socket route.
+     * @param emitTopic The topic to emit the response on.
+     * @param data The incoming data.
+     * @internal
+     */
+    async handleRequestSocket(socketRouteProcessors, socketRoute, socket, fullPath, emitTopic, request) {
+        const httpServerRequest = {
+            method: web.HttpMethod.GET,
+            url: fullPath,
+            query: socket.handshake.query,
+            headers: socket.handshake.headers,
+            body: request.body
+        };
+        const httpResponse = {};
+        const httpRequestIdentity = {};
+        const processorState = {
+            socketId: socket.id
+        };
+        delete httpServerRequest.query?.EIO;
+        delete httpServerRequest.query?.transport;
+        await this.runProcessorsSocket(socketRouteProcessors, socketRoute, httpServerRequest, httpResponse, httpRequestIdentity, processorState, emitTopic, async (topic, response) => {
+            await socket.emit(topic, response);
+        });
+    }
+    /**
+     * Run the socket processors for the route.
+     * @param socketRouteProcessors The processors to run.
+     * @param socketRoute The route to process.
+     * @param httpServerRequest The incoming request.
+     * @param httpResponse The outgoing response.
+     * @param httpRequestIdentity The identity context for the request.
+     * @param processorState The state handed through the processors.
+     * @param requestTopic The topic of the request.
+     * @internal
+     */
+    async runProcessorsSocket(socketRouteProcessors, socketRoute, httpServerRequest, httpResponse, httpRequestIdentity, processorState, requestTopic, responseEmitter) {
+        // Custom emit method which will also call the post processors
+        const postProcessEmit = async (topic, response, responseProcessorState) => {
+            await responseEmitter(topic, response);
+            try {
+                // The post processors are called after the response has been emitted
+                for (const postSocketRouteProcessor of socketRouteProcessors) {
+                    if (core.Is.function(postSocketRouteProcessor.post)) {
+                        await postSocketRouteProcessor.post(httpServerRequest, response, socketRoute, httpRequestIdentity, responseProcessorState);
+                    }
+                }
+            }
+            catch (err) {
+                this._loggingConnector?.log({
+                    level: "error",
+                    ts: Date.now(),
+                    source: this.CLASS_NAME,
+                    message: `${FastifyWebServer._CLASS_NAME_CAMEL_CASE}.postProcessorError`,
+                    error: core.BaseError.fromError(err),
+                    data: {
+                        route: socketRoute.path
+                    }
+                });
+            }
+        };
+        try {
+            for (const socketRouteProcessor of socketRouteProcessors) {
+                if (core.Is.function(socketRouteProcessor.pre)) {
+                    await socketRouteProcessor.pre(httpServerRequest, httpResponse, socketRoute, httpRequestIdentity, processorState);
+                }
+            }
+            // We always call all the processors regardless of any response set by a previous processor.
+            // But if a pre processor sets a status code, we will emit the response manually, as the pre
+            // and post processors do not receive the emit method, they just populate the response object.
+            if (!core.Is.empty(httpResponse.statusCode)) {
+                await postProcessEmit(requestTopic, httpResponse, processorState);
+            }
+            for (const socketRouteProcessor of socketRouteProcessors) {
+                if (core.Is.function(socketRouteProcessor.process)) {
+                    await socketRouteProcessor.process(httpServerRequest, httpResponse, socketRoute, httpRequestIdentity, processorState, async (topic, processResponse) => {
+                        await postProcessEmit(topic, processResponse, processorState);
+                    });
+                }
+            }
+            // If the processors set the status to any kind of error then we should emit this manually
+            if (core.Is.integer(httpResponse.statusCode) &&
+                httpResponse.statusCode >= web.HttpStatusCode.badRequest) {
+                await postProcessEmit(requestTopic, httpResponse, processorState);
+            }
+        }
+        catch (err) {
+            // Emit any unhandled errors manually
+            const { error, httpStatusCode } = apiModels.HttpErrorHelper.processError(err, this._includeErrorStack);
+            apiModels.HttpErrorHelper.buildResponse(httpResponse, error, httpStatusCode);
+            await postProcessEmit(requestTopic, httpResponse, processorState);
+        }
+    }
     /**
      * Initialize the cors options.
      * @param options The web server options.

package/dist/esm/index.mjs

@@ -1,10 +1,24 @@
 import FastifyCompress from '@fastify/compress';
 import FastifyCors from '@fastify/cors';
 import { HttpErrorHelper } from '@twin.org/api-models';
+import { JsonLdMimeTypeProcessor } from '@twin.org/api-processors';
 import { StringHelper, Is, GeneralError, BaseError } from '@twin.org/core';
 import { LoggingConnectorFactory } from '@twin.org/logging-models';
 import { HttpStatusCode, HttpMethod, HeaderTypes } from '@twin.org/web';
 import Fastify from 'fastify';
+import fp from 'fastify-plugin';
+import { Server } from 'socket.io';
+
+// This is a clone of fastify-socket.io which runs with recent fastify versions.
+const fastifySocketIO = fp(async (fastify, opts) => {
+    const ioServer = new Server(fastify.server, opts);
+    fastify.decorate("io", ioServer);
+    fastify.addHook("preClose", done => {
+        ioServer.disconnectSockets();
+        ioServer.close();
+        done();
+    });
+}, { fastify: ">=5.x.x", name: "socket.io" });
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
@@ -46,23 +60,49 @@ class FastifyWebServer {
      * @internal
      */
     _fastify;
+    /**
+     * The options for the socket server.
+     * @internal
+     */
+    _socketConfig;
     /**
      * Whether the server has been started.
      * @internal
      */
     _started;
+    /**
+     * The mime type processors.
+     * @internal
+     */
+    _mimeTypeProcessors;
+    /**
+     * Include the stack with errors.
+     * @internal
+     */
+    _includeErrorStack;
     /**
      * Create a new instance of FastifyWebServer.
      * @param options The options for the server.
-     * @param options.loggingConnectorType The type of the logging connector to use, if undefined, no logging will happen.
-     * @param options.config Additional options for the Fastify server.
      */
     constructor(options) {
         this._loggingConnector = Is.stringValue(options?.loggingConnectorType)
             ? LoggingConnectorFactory.get(options.loggingConnectorType)
             : undefined;
-        this._fastify = Fastify({ maxParamLength: 2000, ...options?.config });
+        this._fastify = Fastify({
+            maxParamLength: 2000,
+            ...options?.config?.web
+        });
+        this._socketConfig = {
+            path: "/socket",
+            ...options?.config?.socket
+        };
         this._started = false;
+        this._mimeTypeProcessors = options?.mimeTypeProcessors ?? [];
+        const hasJsonLd = this._mimeTypeProcessors.find(processor => processor.CLASS_NAME === "json-ld");
+        if (!hasJsonLd) {
+            this._mimeTypeProcessors.push(new JsonLdMimeTypeProcessor());
+        }
+        this._includeErrorStack = options?.config?.includeErrorStack ?? false;
     }
     /**
      * Get the web server instance.
@@ -73,14 +113,19 @@ class FastifyWebServer {
     }
     /**
      * Build the server.
-     * @param restRouteProcessors The hooks to process the incoming requests.
+     * @param restRouteProcessors The processors for incoming requests over REST.
      * @param restRoutes The REST routes.
+     * @param socketRouteProcessors The processors for incoming requests over Sockets.
+     * @param socketRoutes The socket routes.
      * @param options Options for building the server.
      * @returns Nothing.
      */
-    async build(restRouteProcessors, restRoutes, options) {
-        if (!Is.arrayValue(restRouteProcessors)) {
-            throw new GeneralError(this.CLASS_NAME, "noProcessors");
+    async build(restRouteProcessors, restRoutes, socketRouteProcessors, socketRoutes, options) {
+        if (Is.arrayValue(restRoutes) && !Is.arrayValue(restRouteProcessors)) {
+            throw new GeneralError(this.CLASS_NAME, "noRestProcessors");
+        }
+        if (Is.arrayValue(socketRoutes) && !Is.arrayValue(socketRouteProcessors)) {
+            throw new GeneralError(this.CLASS_NAME, "noSocketProcessors");
         }
         await this._loggingConnector?.log({
             level: "info",
@@ -90,8 +135,25 @@ class FastifyWebServer {
         });
         this._options = options;
         await this._fastify.register(FastifyCompress);
+        if (Is.arrayValue(socketRoutes)) {
+            await this._fastify.register(fastifySocketIO, this._socketConfig);
+        }
+        if (Is.arrayValue(this._mimeTypeProcessors)) {
+            for (const contentTypeHandler of this._mimeTypeProcessors) {
+                this._fastify.addContentTypeParser(contentTypeHandler.getTypes(), { parseAs: "buffer" }, (request, body, done) => {
+                    // Fastify does not handle this method correctly if it is async
+                    // so we have to use the callback method
+                    contentTypeHandler
+                        .handle(body)
+                        // eslint-disable-next-line promise/prefer-await-to-then, promise/no-callback-in-promise
+                        .then(processed => done(null, processed))
+                        // eslint-disable-next-line promise/prefer-await-to-then, promise/no-callback-in-promise
+                        .catch(err => done(BaseError.fromError(err)));
+                });
+            }
+        }
         await this.initCors(options);
-        this._fastify.setNotFoundHandler({}, async (request, reply) => this.handleRequest(restRouteProcessors, request, reply));
+        this._fastify.setNotFoundHandler({}, async (request, reply) => this.handleRequestRest(restRouteProcessors ?? [], request, reply));
         this._fastify.setErrorHandler(async (error, request, reply) => {
             // If code property is set this is a fastify error
             // otherwise it's from our framework
@@ -121,22 +183,8 @@ class FastifyWebServer {
                 error: err
             });
         });
-        // Add the routes to the server.
-        for (const restRoute of restRoutes) {
-            let path = StringHelper.trimTrailingSlashes(restRoute.path);
-            if (!path.startsWith("/")) {
-                path = `/${path}`;
-            }
-            await this._loggingConnector?.log({
-                level: "info",
-                ts: Date.now(),
-                source: this.CLASS_NAME,
-                message: `${FastifyWebServer._CLASS_NAME_CAMEL_CASE}.restRouteAdded`,
-                data: { route: path, method: restRoute.method }
-            });
-            const method = restRoute.method.toLowerCase();
-            this._fastify[method](path, async (request, reply) => this.handleRequest(restRouteProcessors, request, reply, restRoute));
-        }
+        await this.addRoutesRest(restRouteProcessors, restRoutes);
+        await this.addRoutesSocket(socketRouteProcessors, socketRoutes);
     }
     /**
      * Start the server.
@@ -201,14 +249,109 @@ class FastifyWebServer {
         }
     }
     /**
-     * Handle the incoming request.
+     * Add the REST routes to the server.
+     * @param restRouteProcessors The processors for the incoming requests.
+     * @param restRoutes The REST routes to add.
+     * @internal
+     */
+    async addRoutesRest(restRouteProcessors, restRoutes) {
+        if (Is.arrayValue(restRouteProcessors) && Is.arrayValue(restRoutes)) {
+            for (const restRoute of restRoutes) {
+                let path = StringHelper.trimTrailingSlashes(restRoute.path);
+                if (!path.startsWith("/")) {
+                    path = `/${path}`;
+                }
+                await this._loggingConnector?.log({
+                    level: "info",
+                    ts: Date.now(),
+                    source: this.CLASS_NAME,
+                    message: `${FastifyWebServer._CLASS_NAME_CAMEL_CASE}.restRouteAdded`,
+                    data: { route: path, method: restRoute.method }
+                });
+                const method = restRoute.method.toLowerCase();
+                this._fastify[method](path, async (request, reply) => this.handleRequestRest(restRouteProcessors, request, reply, restRoute));
+            }
+        }
+    }
+    /**
+     * Add the socket routes to the server.
+     * @param socketRouteProcessors The processors for the incoming requests.
+     * @param socketRoutes The socket routes to add.
+     * @internal
+     */
+    async addRoutesSocket(socketRouteProcessors, socketRoutes) {
+        if (Is.arrayValue(socketRouteProcessors) && Is.arrayValue(socketRoutes)) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const io = this._fastify.io;
+            for (const socketRoute of socketRoutes) {
+                const path = StringHelper.trimLeadingSlashes(StringHelper.trimTrailingSlashes(socketRoute.path));
+                const pathParts = path.split("/");
+                await this._loggingConnector?.log({
+                    level: "info",
+                    ts: Date.now(),
+                    source: this.CLASS_NAME,
+                    message: `${FastifyWebServer._CLASS_NAME_CAMEL_CASE}.socketRouteAdded`,
+                    data: { route: `/${path}` }
+                });
+                const socketNamespace = io.of(`/${pathParts[0]}`);
+                const topic = pathParts.slice(1).join("/");
+                socketNamespace.on("connection", async (socket) => {
+                    const httpServerRequest = {
+                        method: HttpMethod.GET,
+                        url: socket.handshake.url,
+                        query: socket.handshake.query,
+                        headers: socket.handshake.headers
+                    };
+                    // Pass the connected information on to any processors
+                    try {
+                        const processorState = {
+                            socketId: socket.id
+                        };
+                        for (const socketRouteProcessor of socketRouteProcessors) {
+                            if (Is.function(socketRouteProcessor.connected)) {
+                                await socketRouteProcessor.connected(httpServerRequest, socketRoute, processorState);
+                            }
+                        }
+                    }
+                    catch (err) {
+                        const { error, httpStatusCode } = HttpErrorHelper.processError(err, this._includeErrorStack);
+                        const response = {};
+                        HttpErrorHelper.buildResponse(response, error, httpStatusCode);
+                        socket.emit(topic, response);
+                    }
+                    socket.on("disconnect", async () => {
+                        try {
+                            const processorState = {
+                                socketId: socket.id
+                            };
+                            // The socket disconnected so notify any processors
+                            for (const socketRouteProcessor of socketRouteProcessors) {
+                                if (Is.function(socketRouteProcessor.disconnected)) {
+                                    await socketRouteProcessor.disconnected(httpServerRequest, socketRoute, processorState);
+                                }
+                            }
+                        }
+                        catch {
+                            // If something fails on a disconnect there is not much we can do with it
+                        }
+                    });
+                    // Handle any incoming messages
+                    socket.on(topic, async (data) => {
+                        await this.handleRequestSocket(socketRouteProcessors, socketRoute, socket, `/${pathParts.join("/")}`, topic, data);
+                    });
+                });
+            }
+        }
+    }
+    /**
+     * Handle the incoming REST request.
      * @param restRouteProcessors The hooks to process the incoming requests.
      * @param request The incoming request.
      * @param reply The outgoing response.
      * @param restRoute The REST route to handle.
      * @internal
      */
-    async handleRequest(restRouteProcessors, request, reply, restRoute) {
+    async handleRequestRest(restRouteProcessors, request, reply, restRoute) {
         const httpServerRequest = {
             method: request.method.toUpperCase(),
             url: `${request.protocol}://${request.hostname}${request.url}`,
@@ -220,21 +363,7 @@ class FastifyWebServer {
         const httpResponse = {};
         const httpRequestIdentity = {};
         const processorState = {};
-        for (const restRouteProcessor of restRouteProcessors) {
-            if (Is.function(restRouteProcessor.pre)) {
-                await restRouteProcessor.pre(httpServerRequest, httpResponse, restRoute, httpRequestIdentity, processorState);
-            }
-        }
-        for (const restRouteProcessor of restRouteProcessors) {
-            if (Is.function(restRouteProcessor.process)) {
-                await restRouteProcessor.process(httpServerRequest, httpResponse, restRoute, httpRequestIdentity, processorState);
-            }
-        }
-        for (const restRouteProcessor of restRouteProcessors) {
-            if (Is.function(restRouteProcessor.post)) {
-                await restRouteProcessor.post(httpServerRequest, httpResponse, restRoute, httpRequestIdentity, processorState);
-            }
-        }
+        await this.runProcessorsRest(restRouteProcessors, restRoute, httpServerRequest, httpResponse, httpRequestIdentity, processorState);
         if (!Is.empty(httpResponse.headers)) {
             for (const header of Object.keys(httpResponse.headers)) {
                 reply.header(header, httpResponse.headers[header]);
@@ -244,6 +373,135 @@ class FastifyWebServer {
             .status((httpResponse.statusCode ?? HttpStatusCode.ok))
             .send(httpResponse.body);
     }
+    /**
+     * Run the REST processors for the route.
+     * @param restRouteProcessors The processors to run.
+     * @param restRoute The route to process.
+     * @param httpServerRequest The incoming request.
+     * @param httpResponse The outgoing response.
+     * @param httpRequestIdentity The identity context for the request.
+     * @internal
+     */
+    async runProcessorsRest(restRouteProcessors, restRoute, httpServerRequest, httpResponse, httpRequestIdentity, processorState) {
+        try {
+            for (const routeProcessor of restRouteProcessors) {
+                if (Is.function(routeProcessor.pre)) {
+                    await routeProcessor.pre(httpServerRequest, httpResponse, restRoute, httpRequestIdentity, processorState);
+                }
+            }
+            for (const routeProcessor of restRouteProcessors) {
+                if (Is.function(routeProcessor.process)) {
+                    await routeProcessor.process(httpServerRequest, httpResponse, restRoute, httpRequestIdentity, processorState);
+                }
+            }
+            for (const routeProcessor of restRouteProcessors) {
+                if (Is.function(routeProcessor.post)) {
+                    await routeProcessor.post(httpServerRequest, httpResponse, restRoute, httpRequestIdentity, processorState);
+                }
+            }
+        }
+        catch (err) {
+            const { error, httpStatusCode } = HttpErrorHelper.processError(err, this._includeErrorStack);
+            HttpErrorHelper.buildResponse(httpResponse, error, httpStatusCode);
+        }
+    }
+    /**
+     * Handle the incoming socket request.
+     * @param socketRouteProcessors The hooks to process the incoming requests.
+     * @param socketRoute The socket route to handle.
+     * @param socket The socket to handle.
+     * @param fullPath The full path of the socket route.
+     * @param emitTopic The topic to emit the response on.
+     * @param data The incoming data.
+     * @internal
+     */
+    async handleRequestSocket(socketRouteProcessors, socketRoute, socket, fullPath, emitTopic, request) {
+        const httpServerRequest = {
+            method: HttpMethod.GET,
+            url: fullPath,
+            query: socket.handshake.query,
+            headers: socket.handshake.headers,
+            body: request.body
+        };
+        const httpResponse = {};
+        const httpRequestIdentity = {};
+        const processorState = {
+            socketId: socket.id
+        };
+        delete httpServerRequest.query?.EIO;
+        delete httpServerRequest.query?.transport;
+        await this.runProcessorsSocket(socketRouteProcessors, socketRoute, httpServerRequest, httpResponse, httpRequestIdentity, processorState, emitTopic, async (topic, response) => {
+            await socket.emit(topic, response);
+        });
+    }
+    /**
+     * Run the socket processors for the route.
+     * @param socketRouteProcessors The processors to run.
+     * @param socketRoute The route to process.
+     * @param httpServerRequest The incoming request.
+     * @param httpResponse The outgoing response.
+     * @param httpRequestIdentity The identity context for the request.
+     * @param processorState The state handed through the processors.
+     * @param requestTopic The topic of the request.
+     * @internal
+     */
+    async runProcessorsSocket(socketRouteProcessors, socketRoute, httpServerRequest, httpResponse, httpRequestIdentity, processorState, requestTopic, responseEmitter) {
+        // Custom emit method which will also call the post processors
+        const postProcessEmit = async (topic, response, responseProcessorState) => {
+            await responseEmitter(topic, response);
+            try {
+                // The post processors are called after the response has been emitted
+                for (const postSocketRouteProcessor of socketRouteProcessors) {
+                    if (Is.function(postSocketRouteProcessor.post)) {
+                        await postSocketRouteProcessor.post(httpServerRequest, response, socketRoute, httpRequestIdentity, responseProcessorState);
+                    }
+                }
+            }
+            catch (err) {
+                this._loggingConnector?.log({
+                    level: "error",
+                    ts: Date.now(),
+                    source: this.CLASS_NAME,
+                    message: `${FastifyWebServer._CLASS_NAME_CAMEL_CASE}.postProcessorError`,
+                    error: BaseError.fromError(err),
+                    data: {
+                        route: socketRoute.path
+                    }
+                });
+            }
+        };
+        try {
+            for (const socketRouteProcessor of socketRouteProcessors) {
+                if (Is.function(socketRouteProcessor.pre)) {
+                    await socketRouteProcessor.pre(httpServerRequest, httpResponse, socketRoute, httpRequestIdentity, processorState);
+                }
+            }
+            // We always call all the processors regardless of any response set by a previous processor.
+            // But if a pre processor sets a status code, we will emit the response manually, as the pre
+            // and post processors do not receive the emit method, they just populate the response object.
+            if (!Is.empty(httpResponse.statusCode)) {
+                await postProcessEmit(requestTopic, httpResponse, processorState);
+            }
+            for (const socketRouteProcessor of socketRouteProcessors) {
+                if (Is.function(socketRouteProcessor.process)) {
+                    await socketRouteProcessor.process(httpServerRequest, httpResponse, socketRoute, httpRequestIdentity, processorState, async (topic, processResponse) => {
+                        await postProcessEmit(topic, processResponse, processorState);
+                    });
+                }
+            }
+            // If the processors set the status to any kind of error then we should emit this manually
+            if (Is.integer(httpResponse.statusCode) &&
+                httpResponse.statusCode >= HttpStatusCode.badRequest) {
+                await postProcessEmit(requestTopic, httpResponse, processorState);
+            }
+        }
+        catch (err) {
+            // Emit any unhandled errors manually
+            const { error, httpStatusCode } = HttpErrorHelper.processError(err, this._includeErrorStack);
+            HttpErrorHelper.buildResponse(httpResponse, error, httpStatusCode);
+            await postProcessEmit(requestTopic, httpResponse, processorState);
+        }
+    }
     /**
      * Initialize the cors options.
      * @param options The web server options.

package/dist/types/fastifySocketIo.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyPluginAsync } from "fastify";
+import { type ServerOptions } from "socket.io";
+declare const fastifySocketIO: FastifyPluginAsync<Partial<ServerOptions>>;
+export default fastifySocketIO;

package/dist/types/fastifyWebServer.d.ts

@@ -1,5 +1,6 @@
-import { type IHttpRestRouteProcessor, type IRestRoute, type IWebServer, type IWebServerOptions } from "@twin.org/api-models";
-import { type FastifyServerOptions, type FastifyInstance } from "fastify";
+import { type IRestRoute, type IRestRouteProcessor, type ISocketRoute, type ISocketRouteProcessor, type IWebServer, type IWebServerOptions } from "@twin.org/api-models";
+import { type FastifyInstance } from "fastify";
+import type { IFastifyWebServerConstructorOptions } from "./models/IFastifyWebServerConstructorOptions";
 /**
  * Implementation of the web server using Fastify.
  */
@@ -11,13 +12,8 @@ export declare class FastifyWebServer implements IWebServer<FastifyInstance> {
     /**
      * Create a new instance of FastifyWebServer.
      * @param options The options for the server.
-     * @param options.loggingConnectorType The type of the logging connector to use, if undefined, no logging will happen.
-     * @param options.config Additional options for the Fastify server.
      */
-    constructor(options?: {
-        loggingConnectorType?: string;
-        config?: FastifyServerOptions;
-    });
+    constructor(options?: IFastifyWebServerConstructorOptions);
     /**
      * Get the web server instance.
      * @returns The web server instance.
@@ -25,12 +21,14 @@ export declare class FastifyWebServer implements IWebServer<FastifyInstance> {
     getInstance(): FastifyInstance;
     /**
      * Build the server.
-     * @param restRouteProcessors The hooks to process the incoming requests.
+     * @param restRouteProcessors The processors for incoming requests over REST.
      * @param restRoutes The REST routes.
+     * @param socketRouteProcessors The processors for incoming requests over Sockets.
+     * @param socketRoutes The socket routes.
      * @param options Options for building the server.
      * @returns Nothing.
      */
-    build(restRouteProcessors: IHttpRestRouteProcessor[], restRoutes: IRestRoute[], options?: IWebServerOptions): Promise<void>;
+    build(restRouteProcessors?: IRestRouteProcessor[], restRoutes?: IRestRoute[], socketRouteProcessors?: ISocketRouteProcessor[], socketRoutes?: ISocketRoute[], options?: IWebServerOptions): Promise<void>;
     /**
      * Start the server.
      * @returns Nothing.

package/dist/types/index.d.ts

@@ -1 +1,3 @@
 export * from "./fastifyWebServer";
+export * from "./models/IFastifyWebServerConfig";
+export * from "./models/IFastifyWebServerConstructorOptions";

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

@@ -0,0 +1,19 @@
+import type { FastifyServerOptions } from "fastify";
+import type { ServerOptions } from "socket.io";
+/**
+ * The configuration for the Fastify web server.
+ */
+export interface IFastifyWebServerConfig {
+    /**
+     * The web server options.
+     */
+    web?: Partial<FastifyServerOptions>;
+    /**
+     * The socket server options.
+     */
+    socket?: Partial<ServerOptions>;
+    /**
+     * Include the stack with errors.
+     */
+    includeErrorStack?: boolean;
+}

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

@@ -0,0 +1,19 @@
+import type { IMimeTypeProcessor } from "@twin.org/api-models";
+import type { IFastifyWebServerConfig } from "./IFastifyWebServerConfig";
+/**
+ * The options for the Fastify web server constructor.
+ */
+export interface IFastifyWebServerConstructorOptions {
+    /**
+     * The type of the logging connector to use, if undefined, no logging will happen.
+     */
+    loggingConnectorType?: string;
+    /**
+     * Additional configuration for the server.
+     */
+    config?: IFastifyWebServerConfig;
+    /**
+     * Additional MIME type processors.
+     */
+    mimeTypeProcessors?: IMimeTypeProcessor[];
+}

package/docs/changelog.md

@@ -1,5 +1,125 @@
 # @twin.org/api-server-fastify - Changelog
 
-## v0.0.1-next.9
+## [0.0.2-next.1](https://github.com/twinfoundation/api/compare/api-server-fastify-v0.0.2-next.0...api-server-fastify-v0.0.2-next.1) (2025-07-08)
+
+
+### Features
+
+* add json-ld mime type processor and auth admin component ([8861791](https://github.com/twinfoundation/api/commit/88617916e23bfbca023dbae1976fe421983a02ff))
+* update dependencies ([1171dc4](https://github.com/twinfoundation/api/commit/1171dc416a9481737f6a640e3cf30145768f37e9))
+* use shared store mechanism ([#19](https://github.com/twinfoundation/api/issues/19)) ([32116df](https://github.com/twinfoundation/api/commit/32116df3b4380a30137f5056f242a5c99afa2df9))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @twin.org/api-core bumped from 0.0.2-next.0 to 0.0.2-next.1
+    * @twin.org/api-models bumped from 0.0.2-next.0 to 0.0.2-next.1
+    * @twin.org/api-processors bumped from 0.0.2-next.0 to 0.0.2-next.1
+
+## 0.0.1 (2025-07-03)
+
+
+### Features
+
+* release to production ([70ee2d5](https://github.com/twinfoundation/api/commit/70ee2d56a1dc9537d7c9c154d4cb78a235678a3a))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @twin.org/api-models bumped from ^0.0.0 to ^0.0.1
+    * @twin.org/api-core bumped from ^0.0.0 to ^0.0.1
+  * devDependencies
+    * @twin.org/api-processors bumped from ^0.0.0 to ^0.0.1
+
+## [0.0.1-next.36](https://github.com/twinfoundation/api/compare/api-server-fastify-v0.0.1-next.35...api-server-fastify-v0.0.1-next.36) (2025-06-17)
+
+
+### Miscellaneous Chores
+
+* **api-server-fastify:** Synchronize repo versions
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @twin.org/api-models bumped from 0.0.1-next.35 to 0.0.1-next.36
+    * @twin.org/api-core bumped from 0.0.1-next.35 to 0.0.1-next.36
+  * devDependencies
+    * @twin.org/api-processors bumped from 0.0.1-next.35 to 0.0.1-next.36
+
+## [0.0.1-next.35](https://github.com/twinfoundation/api/compare/api-server-fastify-v0.0.1-next.34...api-server-fastify-v0.0.1-next.35) (2025-06-11)
+
+
+### Features
+
+* update dependencies ([1171dc4](https://github.com/twinfoundation/api/commit/1171dc416a9481737f6a640e3cf30145768f37e9))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @twin.org/api-models bumped from 0.0.1-next.34 to 0.0.1-next.35
+    * @twin.org/api-core bumped from 0.0.1-next.34 to 0.0.1-next.35
+  * devDependencies
+    * @twin.org/api-processors bumped from 0.0.1-next.34 to 0.0.1-next.35
+
+## [0.0.1-next.34](https://github.com/twinfoundation/api/compare/api-server-fastify-v0.0.1-next.33...api-server-fastify-v0.0.1-next.34) (2025-05-27)
+
+
+### Miscellaneous Chores
+
+* **api-server-fastify:** Synchronize repo versions
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @twin.org/api-models bumped from 0.0.1-next.33 to 0.0.1-next.34
+    * @twin.org/api-core bumped from 0.0.1-next.33 to 0.0.1-next.34
+  * devDependencies
+    * @twin.org/api-processors bumped from 0.0.1-next.33 to 0.0.1-next.34
+
+## [0.0.1-next.33](https://github.com/twinfoundation/api/compare/api-server-fastify-v0.0.1-next.32...api-server-fastify-v0.0.1-next.33) (2025-04-17)
+
+
+### Features
+
+* use shared store mechanism ([#19](https://github.com/twinfoundation/api/issues/19)) ([32116df](https://github.com/twinfoundation/api/commit/32116df3b4380a30137f5056f242a5c99afa2df9))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @twin.org/api-models bumped from 0.0.1-next.32 to 0.0.1-next.33
+    * @twin.org/api-core bumped from 0.0.1-next.32 to 0.0.1-next.33
+  * devDependencies
+    * @twin.org/api-processors bumped from 0.0.1-next.32 to 0.0.1-next.33
+
+## [0.0.1-next.32](https://github.com/twinfoundation/api/compare/api-server-fastify-v0.0.1-next.31...api-server-fastify-v0.0.1-next.32) (2025-03-28)
+
+
+### Miscellaneous Chores
+
+* **api-server-fastify:** Synchronize repo versions
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @twin.org/api-models bumped from 0.0.1-next.31 to 0.0.1-next.32
+    * @twin.org/api-core bumped from 0.0.1-next.31 to 0.0.1-next.32
+  * devDependencies
+    * @twin.org/api-processors bumped from next to 0.0.1-next.32
+
+## v0.0.1-next.31
 
 - Initial Release

package/docs/reference/classes/FastifyWebServer.md

@@ -8,29 +8,23 @@ Implementation of the web server using Fastify.
 
 ## Constructors
 
-### new FastifyWebServer()
+### Constructor
 
-> **new FastifyWebServer**(`options`?): [`FastifyWebServer`](FastifyWebServer.md)
+> **new FastifyWebServer**(`options?`): `FastifyWebServer`
 
 Create a new instance of FastifyWebServer.
 
 #### Parameters
 
-• **options?**
+##### options?
 
-The options for the server.
-
-• **options.loggingConnectorType?**: `string`
-
-The type of the logging connector to use, if undefined, no logging will happen.
-
-• **options.config?**: `FastifyServerOptions`
+[`IFastifyWebServerConstructorOptions`](../interfaces/IFastifyWebServerConstructorOptions.md)
 
-Additional options for the Fastify server.
+The options for the server.
 
 #### Returns
 
-[`FastifyWebServer`](FastifyWebServer.md)
+`FastifyWebServer`
 
 ## Properties
 
@@ -44,13 +38,13 @@ Runtime name for the class.
 
 ### getInstance()
 
-> **getInstance**(): `FastifyInstance`\<`RawServerDefault`, `IncomingMessage`, `ServerResponse`\<`IncomingMessage`\>, `FastifyBaseLogger`, `FastifyTypeProviderDefault`\>
+> **getInstance**(): `FastifyInstance`
 
 Get the web server instance.
 
 #### Returns
 
-`FastifyInstance`\<`RawServerDefault`, `IncomingMessage`, `ServerResponse`\<`IncomingMessage`\>, `FastifyBaseLogger`, `FastifyTypeProviderDefault`\>
+`FastifyInstance`
 
 The web server instance.
 
@@ -62,21 +56,39 @@ The web server instance.
 
 ### build()
 
-> **build**(`restRouteProcessors`, `restRoutes`, `options`?): `Promise`\<`void`\>
+> **build**(`restRouteProcessors?`, `restRoutes?`, `socketRouteProcessors?`, `socketRoutes?`, `options?`): `Promise`\<`void`\>
 
 Build the server.
 
 #### Parameters
 
-• **restRouteProcessors**: `IHttpRestRouteProcessor`[]
+##### restRouteProcessors?
+
+`IRestRouteProcessor`[]
+
+The processors for incoming requests over REST.
 
-The hooks to process the incoming requests.
+##### restRoutes?
 
-• **restRoutes**: `IRestRoute`\<`any`, `any`\>[]
+`IRestRoute`\<`any`, `any`\>[]
 
 The REST routes.
 
-• **options?**: `IWebServerOptions`
+##### socketRouteProcessors?
+
+`ISocketRouteProcessor`[]
+
+The processors for incoming requests over Sockets.
+
+##### socketRoutes?
+
+`ISocketRoute`\<`any`, `any`\>[]
+
+The socket routes.
+
+##### options?
+
+`IWebServerOptions`
 
 Options for building the server.
 

package/docs/reference/index.md

@@ -3,3 +3,8 @@
 ## Classes
 
 - [FastifyWebServer](classes/FastifyWebServer.md)
+
+## Interfaces
+
+- [IFastifyWebServerConfig](interfaces/IFastifyWebServerConfig.md)
+- [IFastifyWebServerConstructorOptions](interfaces/IFastifyWebServerConstructorOptions.md)

package/docs/reference/interfaces/IFastifyWebServerConfig.md

@@ -0,0 +1,27 @@
+# Interface: IFastifyWebServerConfig
+
+The configuration for the Fastify web server.
+
+## Properties
+
+### web?
+
+> `optional` **web**: `Partial`\<`FastifyServerOptions`\>
+
+The web server options.
+
+***
+
+### socket?
+
+> `optional` **socket**: `Partial`\<`ServerOptions`\>
+
+The socket server options.
+
+***
+
+### includeErrorStack?
+
+> `optional` **includeErrorStack**: `boolean`
+
+Include the stack with errors.

package/docs/reference/interfaces/IFastifyWebServerConstructorOptions.md

@@ -0,0 +1,27 @@
+# Interface: IFastifyWebServerConstructorOptions
+
+The options for the Fastify web server constructor.
+
+## Properties
+
+### loggingConnectorType?
+
+> `optional` **loggingConnectorType**: `string`
+
+The type of the logging connector to use, if undefined, no logging will happen.
+
+***
+
+### config?
+
+> `optional` **config**: [`IFastifyWebServerConfig`](IFastifyWebServerConfig.md)
+
+Additional configuration for the server.
+
+***
+
+### mimeTypeProcessors?
+
+> `optional` **mimeTypeProcessors**: `IMimeTypeProcessor`[]
+
+Additional MIME type processors.

package/locales/en.json

@@ -7,6 +7,9 @@
 		"stopped": "The Web Server was stopped",
 		"badRequest": "The web server could not handle the request",
 		"restRouteAdded": "Added REST route \"{route}\" \"{method}\"",
-		"noProcessors": "You must configure at least one processor"
+		"socketRouteAdded": "Added socket route \"{route}\"",
+		"noRestProcessors": "You must configure at least one REST processor",
+		"noSocketProcessors": "You must configure at least one socket processor",
+		"postProcessorError": "There was a failure after in a post processor for route \"{route}\""
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@twin.org/api-server-fastify",
-	"version": "0.0.1-next.9",
+	"version": "0.0.2-next.1",
 	"description": "Use Fastify as the core web server for APIs",
 	"repository": {
 		"type": "git",
@@ -14,24 +14,26 @@
 		"node": ">=20.0.0"
 	},
 	"dependencies": {
-		"@fastify/compress": "8.0.1",
-		"@fastify/cors": "10.0.1",
-		"@twin.org/api-core": "0.0.1-next.9",
-		"@twin.org/api-models": "0.0.1-next.9",
+		"@fastify/compress": "8.0.3",
+		"@fastify/cors": "11.0.1",
+		"@twin.org/api-core": "0.0.2-next.1",
+		"@twin.org/api-models": "0.0.2-next.1",
+		"@twin.org/api-processors": "0.0.2-next.1",
 		"@twin.org/core": "next",
 		"@twin.org/logging-models": "next",
 		"@twin.org/nameof": "next",
 		"@twin.org/web": "next",
-		"fastify": "5.0.0"
+		"fastify": "5.3.3",
+		"socket.io": "4.8.1"
 	},
 	"main": "./dist/cjs/index.cjs",
 	"module": "./dist/esm/index.mjs",
 	"types": "./dist/types/index.d.ts",
 	"exports": {
 		".": {
+			"types": "./dist/types/index.d.ts",
 			"require": "./dist/cjs/index.cjs",
-			"import": "./dist/esm/index.mjs",
-			"types": "./dist/types/index.d.ts"
+			"import": "./dist/esm/index.mjs"
 		}
 	},
 	"files": [