@telorun/http-server 0.1.3 → 0.1.5

package/dist/http-server-controller.js

@@ -1,30 +1,65 @@
 import swagger from "@fastify/swagger";
 import apiReference from "@scalar/fastify-api-reference";
+import addFormats from "ajv-formats";
 import Fastify from "fastify";
+import { dispatchResponse } from "./http-api-controller.js";
 class HttpServer {
     releaseHold = null;
+    pluginsInitialized = false;
     app;
     host;
     port;
     baseUrl;
     resource;
     ctx;
-    constructor(resource, ctx) {
+    resolvedNotFoundHandler;
+    constructor(resource, ctx, resolvedNotFoundHandler = null) {
         this.resource = resource;
         this.ctx = ctx;
         this.host = resource.host || "0.0.0.0";
         this.port = Number(resource.port || 0);
         this.baseUrl = resource.baseUrl ?? `http://${this.host}:${this.port}`;
+        this.resolvedNotFoundHandler = resolvedNotFoundHandler;
         if (!this.port) {
             throw new Error("Http.Server port is required");
         }
-        this.app = Fastify({ logger: true });
+        this.app = Fastify({ logger: resource.logger, ajv: { plugins: [addFormats.default] } });
     }
     async init() {
-        this.setupPlugins();
+        if (!this.pluginsInitialized) {
+            await this.setupPlugins();
+            this.pluginsInitialized = true;
+        }
         this.setupRoutes();
     }
     async setupPlugins() {
+        for (const { contentType, parser } of this.resource.contentTypeParsers ?? []) {
+            if (parser) {
+                this.app.addContentTypeParser(contentType, { parseAs: "string" }, async (_req, body, done) => {
+                    try {
+                        done(null, await parser.invoke({ body }));
+                    }
+                    catch (err) {
+                        done(err, undefined);
+                    }
+                });
+            }
+            else {
+                this.app.addContentTypeParser(contentType, { parseAs: "string" }, (_req, body, done) => {
+                    done(null, body);
+                });
+            }
+        }
+        // Register custom error handler for validation errors
+        this.app.setErrorHandler((error, request, reply) => {
+            const mappedError = convertFastifyValidationError(error);
+            if (mappedError) {
+                reply.code(400);
+                return reply.send(mappedError);
+            }
+            // Let Fastify handle other errors normally
+            throw error;
+        });
         if (this.resource.openapi) {
             const servers = [];
             // const routesByName = new Map<string, HttpRouteResource>();
@@ -56,12 +91,41 @@ class HttpServer {
             const type = mount.type || "";
             const { kind, name } = parseType(type);
             const prefix = mount.path || "";
-            const api = this.ctx.getResourcesByName(kind, name);
+            const api = this.ctx.moduleContext.getInvocable(name);
             if (!api) {
                 throw new Error(`Failed to mount Http.Api at "${prefix}": ${type} not found`);
             }
             api.register(this.app, prefix);
         }
+        if (this.resolvedNotFoundHandler) {
+            const handler = this.resolvedNotFoundHandler;
+            this.app.setNotFoundHandler(async (request, reply) => {
+                const normalizedHeaders = {};
+                for (const [key, value] of Object.entries(request.headers)) {
+                    normalizedHeaders[key.toLowerCase()] = value;
+                }
+                const requestContext = {
+                    request: {
+                        method: request.method,
+                        path: request.url,
+                        params: request.params || {},
+                        query: request.query || {},
+                        headers: normalizedHeaders,
+                        body: request.body,
+                    },
+                };
+                const result = await this.ctx.invoke(handler.kind, handler.name, requestContext);
+                if (handler.response) {
+                    return dispatchResponse(handler.response, result, requestContext, this.ctx.moduleContext, this.ctx.validateSchema.bind(this.ctx), reply);
+                }
+                const status = result?.status ?? 200;
+                reply.code(status);
+                if (result?.headers) {
+                    Object.entries(result.headers).forEach(([key, value]) => reply.header(key, value));
+                }
+                return reply.send(result?.body ?? result);
+            });
+        }
     }
     async run() {
         this.releaseHold = this.ctx.acquireHold();
@@ -92,8 +156,18 @@ class HttpServer {
         await this.app.close();
     }
 }
-export function create(resource, ctx) {
-    return new HttpServer(resource, ctx);
+export async function create(resource, ctx) {
+    let resolvedNotFoundHandler = null;
+    if (resource.notFoundHandler) {
+        const resolved = ctx.resolveChildren(resource.notFoundHandler.invoke);
+        resolvedNotFoundHandler = {
+            kind: resolved.kind,
+            name: resolved.name,
+            inputs: resource.notFoundHandler.invoke.inputs ?? {},
+            response: resource.notFoundHandler.response,
+        };
+    }
+    return new HttpServer(resource, ctx, resolvedNotFoundHandler);
 }
 function parseType(type) {
     const separator = type.lastIndexOf(".");
@@ -102,3 +176,65 @@ function parseType(type) {
     }
     return { kind: type.slice(0, separator), name: type.slice(separator + 1) };
 }
+/**
+ * Converts Fastify validation errors to standardized Telo format
+ * Returns null if the error is not a validation error
+ */
+function convertFastifyValidationError(error) {
+    // Check if this is a Fastify validation error
+    if (!error || typeof error !== "object" || error.code !== "FST_ERR_VALIDATION") {
+        return null;
+    }
+    const message = error.message || "";
+    const details = [];
+    // Parse Fastify validation error message to extract location and field
+    // Format examples:
+    // "querystring must have required property 'name'"
+    // "body must be object"
+    // "params.userId must be string"
+    let location = "body"; // default
+    let fieldPath = "";
+    let validationMessage = "Validation failed";
+    // Try to extract location from message
+    if (message.includes("querystring")) {
+        location = "query";
+    }
+    else if (message.includes("params")) {
+        location = "params";
+    }
+    else if (message.includes("headers")) {
+        location = "headers";
+    }
+    else if (message.includes("body")) {
+        location = "body";
+    }
+    // Extract field name from "must have required property 'fieldName'" pattern
+    const requiredMatch = message.match(/must have required property '([^']+)'/);
+    if (requiredMatch) {
+        fieldPath = requiredMatch[1];
+        validationMessage = `is a required property`;
+    }
+    else {
+        // Extract field from "fieldName must be" pattern
+        const fieldMatch = message.match(/^(?:querystring|body|params|headers)\.?(\w+)\s/);
+        if (fieldMatch) {
+            fieldPath = fieldMatch[1];
+        }
+        validationMessage = message
+            .replace(/^(?:querystring|body|params|headers)\.?\w*\s/, "")
+            .replace(" must ", " ");
+    }
+    if (fieldPath || message) {
+        details.push({
+            location,
+            path: fieldPath,
+            message: validationMessage,
+        });
+    }
+    return {
+        error: "ValidationError",
+        message: "Request validation failed",
+        status: 400,
+        details,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telorun/http-server",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -17,12 +17,13 @@
     }
   },
   "dependencies": {
+    "@fastify/swagger": "^9.6.1",
+    "@scalar/fastify-api-reference": "^1.44.6",
     "@sinclair/typebox": "^0.34.48",
     "ajv": "^8.17.1",
+    "ajv-formats": "^3.0.1",
     "fastify": "^5.7.2",
-    "@fastify/swagger": "^9.6.1",
-    "@scalar/fastify-api-reference": "^1.44.6",
-    "@telorun/sdk": "0.2.4"
+    "@telorun/sdk": "0.2.6"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",