@jaypie/fabric 0.2.0 → 0.2.2

package/dist/cjs/http/index.cjs

@@ -681,42 +681,68 @@ async function processField(fieldName, value, definition) {
     }
     return convertedValue;
 }
+/**
+ * Run serializer hook if provided
+ * Returns transformed output or original if serializer returns undefined/null/void
+ */
+async function runSerializer(data, serializer, context) {
+    if (!serializer) {
+        return data.output;
+    }
+    const result = await serializer(data, context);
+    if (result !== undefined && result !== null) {
+        return result;
+    }
+    return data.output;
+}
 /**
  * Fabric a service function
  *
- * Service builds a function that initiates a "controller" step that:
+ * Service builds a function that:
  * - Parses the input if it is a string to object
  * - Fabrics each input field to its type
  * - Calls the validation function or regular expression or checks the array
- * - Calls the service function and returns the response
+ * - Calls the service function
+ * - Calls the serializer hook (can transform output)
+ * - Returns the response
  *
  * The returned function has config properties for introspection.
  */
 function fabricService(config) {
-    const { input: inputDefinitions, service } = config;
+    const { input: inputDefinitions, serializer, service } = config;
     const handler = async (rawInput, context) => {
         // Parse input (handles string JSON)
         const parsedInput = parseInput(rawInput);
         // If no input definitions, pass through to service or return parsed input
         if (!inputDefinitions) {
+            let output;
             if (service) {
-                return service(parsedInput, context);
+                output = await service(parsedInput, context);
+            }
+            else {
+                output = parsedInput;
             }
-            return parsedInput;
+            // Run serializer
+            return (await runSerializer({ input: parsedInput, output }, serializer, context));
         }
         // Process all fields in parallel
         const entries = Object.entries(inputDefinitions);
         const processedValues = await Promise.all(entries.map(([fieldName, definition]) => processField(fieldName, parsedInput[fieldName], definition)));
         // Build processed input object
-        const processedInput = {};
+        const processedInputObj = {};
         entries.forEach(([fieldName], index) => {
-            processedInput[fieldName] = processedValues[index];
+            processedInputObj[fieldName] = processedValues[index];
         });
-        // Return processed input if no service, otherwise call service
+        // Call service or return processed input
+        let output;
         if (service) {
-            return service(processedInput, context);
+            output = await service(processedInputObj, context);
+        }
+        else {
+            output = processedInputObj;
         }
-        return processedInput;
+        // Run serializer hook
+        return (await runSerializer({ input: processedInputObj, output }, serializer, context));
     };
     // Attach config properties directly to handler for flat access
     const typedHandler = handler;
@@ -727,6 +753,8 @@ function fabricService(config) {
         typedHandler.description = config.description;
     if (config.input !== undefined)
         typedHandler.input = config.input;
+    if (config.serializer !== undefined)
+        typedHandler.serializer = config.serializer;
     if (config.service !== undefined)
         typedHandler.service = config.service;
     return typedHandler;
@@ -1144,7 +1172,8 @@ exports.HttpStreamEventType = void 0;
  * Check if event is API Gateway v2 format
  */
 function isApiGatewayV2Event(event) {
-    return "requestContext" in event && "http" in event.requestContext;
+    return ("requestContext" in event &&
+        "http" in event.requestContext);
 }
 /**
  * Check if entry is a FabricHttpServerRoute (has service property)
@@ -1194,7 +1223,8 @@ function matchRoute(requestPath, route) {
     const requestSegments = requestPath.split("/").filter(Boolean);
     const routeSegments = route.segments;
     // Check segment count (allow route to have optional params)
-    if (requestSegments.length < routeSegments.filter((s) => !s.endsWith("?")).length) {
+    if (requestSegments.length <
+        routeSegments.filter((s) => !s.endsWith("?")).length) {
         return undefined;
     }
     if (requestSegments.length > routeSegments.length) {
@@ -1350,7 +1380,7 @@ function FabricHttpServer(config) {
      */
     const handler = async (event) => {
         // Extract request data from API Gateway event
-        const { body, headers, method, path: requestPath, queryString, pathParams } = extractRequestData(event);
+        const { body, headers, method, path: requestPath, queryString, pathParams, } = extractRequestData(event);
         // Normalize headers to Headers object for consistency
         const headersObj = new Headers(headers);
         const origin = headersObj.get("origin");