@telorun/http-server 0.1.3 → 0.1.5

package/src/http-server-controller.ts

@@ -1,26 +1,22 @@
 import swagger from "@fastify/swagger";
 import apiReference from "@scalar/fastify-api-reference";
-import type { ResourceContext, ResourceInstance, RuntimeResource } from "@telorun/sdk";
+import type {
+  Invocable,
+  KindRef,
+  ResourceContext,
+  ResourceInstance,
+  RuntimeResource,
+} from "@telorun/sdk";
+import addFormats from "ajv-formats";
 import Fastify, { FastifyInstance } from "fastify";
-import { HttpServerApi } from "./http-api-controller.js";
-
-type HttpRouteResource = RuntimeResource & {
-  metadata?: { path?: string; method?: string };
-  path?: string;
-  method?: string;
-  handler?: HttpHandlerSpec;
-  request?: HttpRequestSchema;
-  response?: {
-    status?: number;
-    headers?: Record<string, string>;
-    body?: any;
-  };
-};
+import { dispatchResponse, HttpServerApi, ResponseEntry } from "./http-api-controller.js";
 
 type HttpServerResource = RuntimeResource & {
   host?: string;
   port?: number;
   baseUrl?: string;
+  logger?: boolean;
+  contentTypeParsers?: Array<{ contentType: string; parser?: Invocable }>;
   openapi?: {
     info: {
       title: string;
@@ -31,70 +27,83 @@ type HttpServerResource = RuntimeResource & {
     path?: string;
     type?: string;
   }>;
+  notFoundHandler?: {
+    invoke: KindRef<Invocable>;
+    response?: ResponseEntry[];
+  };
 };
 
-type HttpApiResource = RuntimeResource & {
-  routes?: Array<
-    | string
-    | {
-        request?: {
-          path?: string;
-          method?: string;
-          query?: Record<string, any>;
-          body?: Record<string, any>;
-          headers?: Record<string, any>;
-        };
-        handler?: HttpHandlerSpec;
-        response?: {
-          status?: number;
-          headers?: Record<string, string>;
-          body?: any;
-        };
-      }
-  >;
-};
-
-type HttpHandlerSpec =
-  | string
-  | {
-      name?: string;
-      inputs?: Record<string, any>;
-    };
-
-type HttpRequestSchema = {
-  query?: Record<string, any>;
-  body?: Record<string, any>;
-  headers?: Record<string, any>;
+type ResolvedHandler = {
+  kind: string;
+  name: string;
+  inputs: Record<string, any>;
+  response?: ResponseEntry[];
 };
 
 class HttpServer implements ResourceInstance {
   private releaseHold: (() => void) | null = null;
+  private pluginsInitialized = false;
   private readonly app: FastifyInstance;
   private readonly host: string;
   private readonly port: number;
   private readonly baseUrl: string;
   private readonly resource: HttpServerResource;
   private readonly ctx: ResourceContext;
+  private readonly resolvedNotFoundHandler: ResolvedHandler | null;
 
-  constructor(resource: HttpServerResource, ctx: ResourceContext) {
+  constructor(
+    resource: HttpServerResource,
+    ctx: ResourceContext,
+    resolvedNotFoundHandler: ResolvedHandler | null = 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 as any] } });
   }
 
   async init() {
-    this.setupPlugins();
+    if (!this.pluginsInitialized) {
+      await this.setupPlugins();
+      this.pluginsInitialized = true;
+    }
     this.setupRoutes();
   }
 
   private 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 as Error, 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>();
@@ -128,13 +137,52 @@ class HttpServer implements ResourceInstance {
       const { kind, name } = parseType(type);
       const prefix = mount.path || "";
 
-      const api: HttpServerApi = this.ctx.getResourcesByName(kind, name) as any;
+      const api = this.ctx.moduleContext.getInvocable(name) as unknown as HttpServerApi;
 
       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: Record<string, any> = {};
+        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 as string),
+          );
+        }
+        return reply.send(result?.body ?? result);
+      });
+    }
   }
 
   async run(): Promise<void> {
@@ -167,11 +215,21 @@ class HttpServer implements ResourceInstance {
   }
 }
 
-export function create(
+export async function create(
   resource: HttpServerResource,
   ctx: ResourceContext,
-): ResourceInstance | null {
-  return new HttpServer(resource, ctx);
+): Promise<ResourceInstance | null> {
+  let resolvedNotFoundHandler: ResolvedHandler | null = null;
+  if (resource.notFoundHandler) {
+    const resolved = ctx.resolveChildren(resource.notFoundHandler.invoke);
+    resolvedNotFoundHandler = {
+      kind: resolved.kind,
+      name: resolved.name,
+      inputs: (resource.notFoundHandler.invoke as any).inputs ?? {},
+      response: resource.notFoundHandler.response,
+    };
+  }
+  return new HttpServer(resource, ctx, resolvedNotFoundHandler);
 }
 
 function parseType(type: string): { kind: string; name: string } {
@@ -181,3 +239,69 @@ function parseType(type: string): { kind: string; name: string } {
   }
   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: any): Record<string, any> | null {
+  // 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/dist/openapi.js

@@ -1,152 +0,0 @@
-import swagger from '@fastify/swagger';
-import apiReference from '@scalar/fastify-api-reference';
-function getResourceConfig(resource) {
-    return resource;
-}
-export function register(ctx) { }
-export function create(resource, ctx) {
-    const openApiResource = resource;
-    const config = getResourceConfig(openApiResource);
-    const apiRefs = config.apis || [];
-    if (apiRefs.length === 0) {
-        throw new Error(`OpenApi.Spec "${resource.metadata.name}" is missing apis`);
-    }
-    const handler = (payload) => {
-        const serverResource = payload?.resource;
-        const app = payload?.app;
-        if (!serverResource || !app) {
-            throw new Error(`OpenApi.Spec handler missing Http.Server resource or Fastify app`);
-        }
-        const matchedApis = resolveApis(apiRefs, ctx);
-        const mounts = getResourceConfig(serverResource).mounts || [];
-        const servers = buildServers(serverResource, mounts, matchedApis);
-        if (servers.length === 0) {
-            return;
-        }
-        const paths = buildPaths(matchedApis, mounts);
-        const info = config.info && typeof config.info === 'object'
-            ? config.info
-            : {
-                title: resource.metadata.name,
-                version: resource.version || '1.0.0',
-            };
-        const routePrefix = config.path || `/openapi/${resource.metadata.name}`;
-        app.register(swagger, {
-            openapi: {
-                openapi: '3.0.0',
-                info,
-                servers,
-                paths,
-            },
-            routePrefix,
-        });
-        app.register(apiReference, {
-            routePrefix,
-        });
-    };
-    const httpServers = ctx.getResources('Http.Server');
-    return {
-        init: async () => {
-            // Register listeners after all resources are initialized
-            for (const server of httpServers) {
-                ctx.on('Http.Server.Ready', server.metadata.name, handler);
-            }
-        },
-        teardown: () => {
-            for (const server of httpServers) {
-                ctx.offResourceEvent('Http.Server', server.metadata.name, 'Ready', handler);
-            }
-        },
-    };
-}
-function resolveApis(apiRefs, ctx) {
-    const apis = [];
-    for (const ref of apiRefs) {
-        const { kind, name } = parseRef(ref);
-        if (!kind || !name) {
-            throw new Error(`Reference not found: ${ref}`);
-        }
-        if (kind !== 'Http.Api' && kind !== 'Http.Route') {
-            throw new Error(`Reference not supported: ${ref}`);
-        }
-        const resource = ctx.kernel.registry.get(kind)?.get(name);
-        if (!resource) {
-            throw new Error(`Reference not found: ${ref}`);
-        }
-        apis.push(resource);
-    }
-    return apis;
-}
-function buildServers(server, mounts, apis) {
-    const config = getResourceConfig(server);
-    const host = config.host || '0.0.0.0';
-    const port = Number(config.port || 0);
-    if (!port) {
-        return [];
-    }
-    // Server URL should be the base URL without mount paths
-    // Paths will include the mount prefix
-    return [{ url: `http://${host}:${port}` }];
-}
-function buildPaths(apis, mounts) {
-    const paths = {};
-    const mountPrefixByType = new Map();
-    for (const mount of mounts) {
-        if (mount.type) {
-            mountPrefixByType.set(mount.type, mount.path || '');
-        }
-    }
-    for (const api of apis) {
-        const prefix = mountPrefixByType.get(`${api.kind}.${api.metadata.name}`) || '';
-        if (api.kind === 'Http.Route') {
-            const config = getResourceConfig(api);
-            const path = joinPath(prefix, api.metadata?.path || config.path || '');
-            const method = (api.metadata?.method ||
-                config.method ||
-                'GET').toLowerCase();
-            if (!path) {
-                continue;
-            }
-            if (!paths[path]) {
-                paths[path] = {};
-            }
-            paths[path][method] = { responses: { '200': { description: 'OK' } } };
-            continue;
-        }
-        const routes = getResourceConfig(api).routes || [];
-        for (const route of routes) {
-            if (typeof route === 'string') {
-                continue;
-            }
-            const request = route.request || {};
-            const path = joinPath(prefix, request.path || '');
-            const method = (request.method || 'GET').toLowerCase();
-            if (!path) {
-                continue;
-            }
-            if (!paths[path]) {
-                paths[path] = {};
-            }
-            paths[path][method] = { responses: { '200': { description: 'OK' } } };
-        }
-    }
-    return paths;
-}
-function parseRef(ref) {
-    const separator = ref.lastIndexOf('.');
-    if (separator <= 0 || separator === ref.length - 1) {
-        return { kind: '', name: '' };
-    }
-    return { kind: ref.slice(0, separator), name: ref.slice(separator + 1) };
-}
-function joinPath(prefix, path) {
-    if (!prefix) {
-        return path;
-    }
-    if (!path) {
-        return prefix;
-    }
-    const trimmedPrefix = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
-    const trimmedPath = path.startsWith('/') ? path : `/${path}`;
-    return `${trimmedPrefix}${trimmedPath}`;
-}

package/dist/test-validation.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test-validation.js

@@ -1,36 +0,0 @@
-// Test file to validate error conversion logic
-import { convertFastifyValidationError } from "./http-api-controller.js";
-function testValidationError() {
-    // Test case 1: Querystring validation error
-    const error1 = {
-        code: "FST_ERR_VALIDATION",
-        message: "querystring must have required property 'name'",
-        statusCode: 400,
-        error: "Bad Request",
-    };
-    const result1 = convertFastifyValidationError(error1);
-    console.log("Test 1 - Querystring required field:", JSON.stringify(result1, null, 2));
-    console.log("✓ Location:", result1?.details[0].location === "query" ? "PASS" : "FAIL");
-    console.log("✓ Path:", result1?.details[0].path === "name" ? "PASS" : "FAIL");
-    console.log("✓ Message:", result1?.details[0].message.includes("required") ? "PASS" : "FAIL");
-    // Test case 2: Body validation error
-    const error2 = {
-        code: "FST_ERR_VALIDATION",
-        message: "body must be object",
-        statusCode: 400,
-    };
-    const result2 = convertFastifyValidationError(error2);
-    console.log("\nTest 2 - Body type error:", JSON.stringify(result2, null, 2));
-    console.log("✓ Location:", result2?.details[0].location === "body" ? "PASS" : "FAIL");
-    // Test case 3: Non-validation error (should return null)
-    const error3 = {
-        code: "ERR_OTHER",
-        message: "Some other error",
-    };
-    const result3 = convertFastifyValidationError(error3);
-    console.log("\nTest 3 - Non-validation error:", result3 === null ? "PASS (null)" : "FAIL (not null)");
-}
-// Only run if this file is executed directly
-if (import.meta.url === `file://${process.argv[1]}`) {
-    testValidationError();
-}