@forklaunch/core 0.7.4 → 0.8.0

package/lib/src/http/index.js

@@ -41,6 +41,8 @@ __export(http_exports, {
   HTTPStatuses: () => HTTPStatuses,
   OpenTelemetryCollector: () => OpenTelemetryCollector,
   delete_: () => delete_,
+  discriminateBody: () => discriminateBody,
+  discriminateResponseBodies: () => discriminateResponseBodies,
   enrichExpressLikeSend: () => enrichExpressLikeSend,
   evaluateTelemetryOptions: () => evaluateTelemetryOptions,
   generateSwaggerDocument: () => generateSwaggerDocument,
@@ -278,6 +280,7 @@ async function parseRequestAuth(req, res, next) {
       req
     ) ?? [];
     if (error != null) {
+      res.type("text/plain");
       res.status(error).send(message);
       next?.(new Error(message));
     }
@@ -548,7 +551,7 @@ function enrichDetails(path, contractDetails, requestSchema, responseSchemas, op
         [ATTR_API_NAME]: req.contractDetails?.name || "unknown",
         [import_semantic_conventions.ATTR_HTTP_REQUEST_METHOD]: req.method,
         [import_semantic_conventions.ATTR_HTTP_ROUTE]: req.originalPath || "unknown",
-        [import_semantic_conventions.ATTR_HTTP_RESPONSE_STATUS_CODE]: res.statusCode
+        [import_semantic_conventions.ATTR_HTTP_RESPONSE_STATUS_CODE]: Number(res.statusCode)
       });
     });
     next?.();
@@ -563,9 +566,9 @@ function hasSend(res) {
   return typeof res === "object" && res !== null && "send" in res;
 }
 
-// src/http/guards/isResponseShape.ts
-function isResponseShape(maybeResponseShape) {
-  return maybeResponseShape != null && "body" in maybeResponseShape && "query" in maybeResponseShape && "params" in maybeResponseShape && "headers" in maybeResponseShape;
+// src/http/guards/isRequestShape.ts
+function isRequestShape(maybeResponseShape) {
+  return maybeResponseShape != null && ("body" in maybeResponseShape || "query" in maybeResponseShape || "params" in maybeResponseShape || "headers" in maybeResponseShape);
 }
 
 // src/http/middleware/request/parse.middleware.ts
@@ -580,7 +583,7 @@ function parse(req, res, next) {
     req.requestSchema,
     request
   );
-  if (parsedRequest.ok && isResponseShape(parsedRequest.value)) {
+  if (parsedRequest.ok && isRequestShape(parsedRequest.value)) {
     req.body = parsedRequest.value.body;
     req.params = parsedRequest.value.params;
     Object.defineProperty(req, "query", {
@@ -589,7 +592,7 @@ function parse(req, res, next) {
       enumerable: true,
       configurable: false
     });
-    req.headers = parsedRequest.value.headers;
+    req.headers = parsedRequest.value.headers ?? {};
   }
   if (!parsedRequest.ok) {
     switch (req.contractDetails.options?.requestValidation) {
@@ -622,11 +625,132 @@ Correlation id: ${req.context.correlationId ?? "No correlation ID"}`
   next?.();
 }
 
+// src/http/router/discriminateBody.ts
+function discriminateBody(schemaValidator, body) {
+  if (body == null) {
+    return void 0;
+  }
+  const maybeTypedBody = body;
+  if ("text" in maybeTypedBody && maybeTypedBody.text != null) {
+    return {
+      contentType: maybeTypedBody.contentType ?? "text/plain",
+      parserType: "text",
+      schema: maybeTypedBody.text
+    };
+  } else if ("json" in maybeTypedBody && maybeTypedBody.json != null) {
+    return {
+      contentType: maybeTypedBody.contentType ?? "application/json",
+      parserType: "json",
+      schema: maybeTypedBody.json
+    };
+  } else if ("file" in maybeTypedBody && maybeTypedBody.file != null) {
+    return {
+      contentType: maybeTypedBody.contentType ?? "application/octet-stream",
+      parserType: "file",
+      schema: maybeTypedBody.file
+    };
+  } else if ("multipartForm" in maybeTypedBody && maybeTypedBody.multipartForm != null) {
+    return {
+      contentType: maybeTypedBody.contentType ?? "multipart/form-data",
+      parserType: "multipart",
+      schema: maybeTypedBody.multipartForm
+    };
+  } else if ("urlEncodedForm" in maybeTypedBody && maybeTypedBody.urlEncodedForm != null) {
+    return {
+      contentType: maybeTypedBody.contentType ?? "application/x-www-form-urlencoded",
+      parserType: "urlEncoded",
+      schema: maybeTypedBody.urlEncodedForm
+    };
+  } else if ("schema" in maybeTypedBody && maybeTypedBody.schema != null) {
+    return {
+      contentType: maybeTypedBody.contentType ?? "application/json",
+      parserType: "text",
+      schema: maybeTypedBody.schema
+    };
+  } else if (schemaValidator.isInstanceOf(
+    maybeTypedBody,
+    schemaValidator.string
+  )) {
+    return {
+      contentType: "text/plain",
+      parserType: "text",
+      schema: maybeTypedBody
+    };
+  } else {
+    return {
+      contentType: "application/json",
+      parserType: "json",
+      schema: maybeTypedBody
+    };
+  }
+}
+function discriminateResponseBodies(schemaValidator, responses) {
+  const discriminatedResponses = {};
+  for (const [statusCode, response] of Object.entries(responses)) {
+    if (response != null && typeof response === "object") {
+      if ("json" in response && response.json != null) {
+        discriminatedResponses[Number(statusCode)] = {
+          contentType: ("contentType" in response && typeof response.contentType === "string" ? response.contentType : "application/json") ?? "application/json",
+          parserType: "json",
+          schema: response.json
+        };
+      } else if ("schema" in response && response.schema != null) {
+        discriminatedResponses[Number(statusCode)] = {
+          contentType: ("contentType" in response && typeof response.contentType === "string" ? response.contentType : "application/json") ?? "application/json",
+          parserType: "text",
+          schema: response.schema
+        };
+      } else if ("text" in response && response.text != null) {
+        discriminatedResponses[Number(statusCode)] = {
+          contentType: ("contentType" in response && typeof response.contentType === "string" ? response.contentType : "text/plain") ?? "text/plain",
+          parserType: "text",
+          schema: response.text
+        };
+      } else if ("file" in response && response.file != null) {
+        discriminatedResponses[Number(statusCode)] = {
+          contentType: ("contentType" in response && typeof response.contentType === "string" ? response.contentType : "application/octet-stream") ?? "application/octet-stream",
+          parserType: "file",
+          schema: response.file
+        };
+      } else if ("event" in response && response.event != null) {
+        discriminatedResponses[Number(statusCode)] = {
+          contentType: ("contentType" in response && typeof response.contentType === "string" ? response.contentType : "text/event-stream") ?? "text/event-stream",
+          parserType: "serverSentEvent",
+          schema: response.event
+        };
+      } else if (schemaValidator.isInstanceOf(
+        response,
+        schemaValidator.string
+      )) {
+        discriminatedResponses[Number(statusCode)] = {
+          contentType: "text/plain",
+          parserType: "text",
+          schema: response
+        };
+      } else {
+        discriminatedResponses[Number(statusCode)] = {
+          contentType: "application/json",
+          parserType: "json",
+          schema: response
+        };
+      }
+    } else {
+      discriminatedResponses[Number(statusCode)] = {
+        contentType: "application/json",
+        parserType: "json",
+        schema: response
+      };
+    }
+  }
+  return discriminatedResponses;
+}
+
 // src/http/router/expressLikeRouter.ts
 var ForklaunchExpressLikeRouter = class {
-  constructor(basePath, schemaValidator, internal, openTelemetryCollector) {
+  constructor(basePath, schemaValidator, internal, postEnrichMiddleware, openTelemetryCollector) {
     this.schemaValidator = schemaValidator;
     this.internal = internal;
+    this.postEnrichMiddleware = postEnrichMiddleware;
     this.openTelemetryCollector = openTelemetryCollector;
     this.basePath = basePath;
   }
@@ -649,6 +773,7 @@ var ForklaunchExpressLikeRouter = class {
         responseSchemas,
         this.openTelemetryCollector
       ),
+      ...this.postEnrichMiddleware,
       parse,
       parseRequestAuth
     ];
@@ -704,12 +829,16 @@ var ForklaunchExpressLikeRouter = class {
   }
   #compile(contractDetails) {
     const schemaValidator = this.schemaValidator;
+    let body = null;
+    if (isHttpContractDetails(contractDetails)) {
+      body = discriminateBody(this.schemaValidator, contractDetails.body);
+    }
     const requestSchema = schemaValidator.compile(
       schemaValidator.schemify({
         ...contractDetails.params ? { params: contractDetails.params } : {},
         ...contractDetails.requestHeaders ? { headers: contractDetails.requestHeaders } : {},
         ...contractDetails.query ? { query: contractDetails.query } : {},
-        ...isHttpContractDetails(contractDetails) && contractDetails.body != null ? { body: contractDetails.body } : {}
+        ...body != null ? { body: body.schema } : {}
       })
     );
     const responseEntries = {
@@ -718,9 +847,16 @@ var ForklaunchExpressLikeRouter = class {
       403: schemaValidator.string,
       404: schemaValidator.string,
       500: schemaValidator.string,
-      ...isPathParamHttpContractDetails(contractDetails) || isHttpContractDetails(contractDetails) ? {
-        ...contractDetails.responses
-      } : {}
+      ...isPathParamHttpContractDetails(contractDetails) || isHttpContractDetails(contractDetails) ? Object.fromEntries(
+        Object.entries(
+          discriminateResponseBodies(
+            this.schemaValidator,
+            contractDetails.responses
+          )
+        ).map(([key, value]) => {
+          return [key, value.schema];
+        })
+      ) : {}
     };
     const responseSchemas = {
       responses: {},
@@ -756,7 +892,7 @@ var ForklaunchExpressLikeRouter = class {
         params: request?.params ?? {},
         query: request?.query ?? {},
         headers: request?.headers ?? {},
-        body: request?.body ?? {},
+        body: discriminateBody(this.schemaValidator, request?.body)?.schema ?? {},
         path: route
       };
       const res = {
@@ -775,6 +911,9 @@ var ForklaunchExpressLikeRouter = class {
         },
         setHeader: (key, value) => {
           responseHeaders[key] = value;
+        },
+        sseEmiter: (generator) => {
+          responseMessage = generator;
         }
       };
       let cursor = handlers.shift();
@@ -800,7 +939,7 @@ var ForklaunchExpressLikeRouter = class {
         }
       });
       return {
-        code: statusCode,
+        code: Number(statusCode),
         response: responseMessage,
         headers: responseHeaders
       };
@@ -1208,10 +1347,17 @@ var ForklaunchExpressLikeApplication = class extends ForklaunchExpressLikeRouter
    *
    * @param {SV} schemaValidator - The schema validator.
    */
-  constructor(schemaValidator, internal, openTelemetryCollector) {
-    super("/", schemaValidator, internal, openTelemetryCollector);
+  constructor(schemaValidator, internal, postEnrichMiddleware, openTelemetryCollector) {
+    super(
+      "/",
+      schemaValidator,
+      internal,
+      postEnrichMiddleware,
+      openTelemetryCollector
+    );
     this.schemaValidator = schemaValidator;
     this.internal = internal;
+    this.postEnrichMiddleware = postEnrichMiddleware;
     this.openTelemetryCollector = openTelemetryCollector;
     this.internal.use(createContext(this.schemaValidator));
     this.internal.use(cors);
@@ -2282,8 +2428,9 @@ var httpStatusCodes_default = HTTPStatuses;
 var import_validator2 = require("@forklaunch/validator");
 function parse2(req, res, next) {
   const { headers, responses } = res.responseSchemas;
+  const statusCode = Number(res.statusCode);
   const parsedResponse = req.schemaValidator.parse(
-    responses?.[res.statusCode],
+    responses?.[statusCode],
     res.bodyData
   );
   const parsedHeaders = req.schemaValidator.parse(
@@ -2311,7 +2458,7 @@ function parse2(req, res, next) {
       default:
       case "error":
         res.type("text/plain");
-        res.status(400);
+        res.status(500);
         if (hasSend(res)) {
           res.send(
             `Invalid response:
@@ -2338,6 +2485,10 @@ ${parseErrors.join("\n\n")}`
   next?.();
 }
 
+// src/http/middleware/response/enrichExpressLikeSend.middleware.ts
+var import_common4 = require("@forklaunch/common");
+var import_stream = require("stream");
+
 // src/http/telemetry/recordMetric.ts
 var import_semantic_conventions3 = require("@opentelemetry/semantic-conventions");
 
@@ -2356,21 +2507,121 @@ function recordMetric(req, res) {
     [ATTR_CORRELATION_ID]: req.context.correlationId,
     [import_semantic_conventions3.ATTR_HTTP_REQUEST_METHOD]: req.method,
     [import_semantic_conventions3.ATTR_HTTP_ROUTE]: req.originalPath,
-    [import_semantic_conventions3.ATTR_HTTP_RESPONSE_STATUS_CODE]: res.statusCode || 0
+    [import_semantic_conventions3.ATTR_HTTP_RESPONSE_STATUS_CODE]: Number(res.statusCode) || 0
   });
   res.metricRecorded = true;
 }
 
 // src/http/middleware/response/enrichExpressLikeSend.middleware.ts
-function enrichExpressLikeSend(instance, req, res, originalSend, data, shouldEnrich) {
-  let parseErrorSent;
-  if (shouldEnrich) {
-    recordMetric(req, res);
-    if (res.statusCode === 404) {
+function enrichExpressLikeSend(instance, req, res, originalOperation, originalSend, data, shouldEnrich) {
+  let errorSent = false;
+  if (data == null) {
+    originalSend.call(instance, data);
+    return;
+  }
+  if (res.statusCode === 404) {
+    res.type("text/plain");
+    res.status(404);
+    logger("error").error("Not Found");
+    originalSend.call(instance, "Not Found");
+    errorSent = true;
+  }
+  const responseBodies = discriminateResponseBodies(
+    req.schemaValidator,
+    req.contractDetails.responses
+  );
+  if (responseBodies != null && responseBodies[Number(res.statusCode)] != null) {
+    res.type(responseBodies[Number(res.statusCode)].contentType);
+  }
+  if (data instanceof File || data instanceof Blob) {
+    if (data instanceof File) {
+      res.setHeader(
+        "Content-Disposition",
+        `attachment; filename="${data.name}"`
+      );
+    }
+    if ((0, import_common4.isNodeJsWriteableStream)(res)) {
+      import_stream.Readable.from((0, import_common4.readableStreamToAsyncIterable)(data.stream())).pipe(
+        res
+      );
+    } else {
+      res.type("text/plain");
+      res.status(500);
+      originalSend.call(instance, "Not a NodeJS WritableStream");
+      errorSent = true;
+    }
+  } else if ((0, import_common4.isAsyncGenerator)(data)) {
+    let firstPass = true;
+    const transformer = new import_stream.Transform({
+      objectMode: true,
+      transform(chunk, _encoding, callback) {
+        if (firstPass) {
+          res.bodyData = chunk;
+          parse2(req, res, (err) => {
+            if (err) {
+              let errorString = err.message;
+              if (res.locals.errorMessage) {
+                errorString += `
+------------------
+${res.locals.errorMessage}`;
+              }
+              logger("error").error(errorString);
+              res.type("text/plain");
+              res.status(500);
+              originalSend.call(instance, errorString);
+              errorSent = true;
+              callback(new Error(errorString));
+            }
+          });
+          firstPass = false;
+        }
+        if (!errorSent) {
+          let data2 = "";
+          for (const [key, value] of Object.entries(chunk)) {
+            data2 += `${key}: ${typeof value === "string" ? value : (0, import_common4.safeStringify)(value)}
+`;
+          }
+          data2 += "\n";
+          callback(null, data2);
+        }
+      }
+    });
+    if ((0, import_common4.isNodeJsWriteableStream)(res)) {
+      import_stream.Readable.from(data).pipe(transformer).pipe(res);
+    } else {
       res.type("text/plain");
-      res.status(404);
-      logger("error").error("Not Found");
-      originalSend.call(instance, "Not Found");
+      res.status(500);
+      originalSend.call(instance, "Not a NodeJS WritableStream");
+      errorSent = true;
+    }
+  } else {
+    const parserType = responseBodies?.[Number(res.statusCode)]?.parserType;
+    res.bodyData = data;
+    if ((0, import_common4.isRecord)(data)) {
+      switch (parserType) {
+        case "json":
+          res.bodyData = "json" in data ? data.json : data;
+          break;
+        case "text":
+          res.bodyData = "text" in data ? data.text : data;
+          break;
+        case "file":
+          res.bodyData = "file" in data ? data.file : data;
+          break;
+        case "serverSentEvent":
+          res.bodyData = "event" in data ? data.event : data;
+          break;
+        case "multipart":
+          res.bodyData = "multipart" in data ? data.multipart : data;
+          break;
+        case void 0:
+          res.bodyData = data;
+          break;
+        default:
+          (0, import_common4.isNever)(parserType);
+          res.bodyData = data;
+          break;
+      }
     }
     parse2(req, res, (err) => {
       if (err) {
@@ -2384,12 +2635,21 @@ ${res.locals.errorMessage}`;
         res.type("text/plain");
         res.status(500);
         originalSend.call(instance, errorString);
-        parseErrorSent = true;
+        errorSent = true;
       }
     });
+    if (!errorSent) {
+      if (typeof data === "string") {
+        res.type("text/plain");
+        originalSend.call(instance, data);
+      } else if (!(data instanceof File)) {
+        res.sent = true;
+        originalOperation.call(instance, data);
+      }
+    }
   }
-  if (!parseErrorSent) {
-    originalSend.call(instance, data);
+  if (shouldEnrich) {
+    recordMetric(req, res);
   }
 }
 
@@ -2428,10 +2688,14 @@ function generateOpenApiDocument(port, tags, paths) {
     paths
   };
 }
-function contentResolver(schemaValidator, body) {
+function contentResolver(schemaValidator, body, contentType) {
   const bodySpec = schemaValidator.openapi(body);
-  return body === schemaValidator.string ? {
-    "plain/text": {
+  return contentType != null ? {
+    [contentType]: {
+      schema: bodySpec
+    }
+  } : body === schemaValidator.string ? {
+    "text/plain": {
       schema: bodySpec
     }
   } : {
@@ -2456,15 +2720,29 @@ function generateSwaggerDocument(schemaValidator, port, routers) {
       }
       const { name, summary, query, requestHeaders } = route.contractDetails;
       const responses = {};
-      for (const key in route.contractDetails.responses) {
+      const discriminatedResponseBodiesResult = discriminateResponseBodies(
+        schemaValidator,
+        route.contractDetails.responses
+      );
+      for (const key in discriminatedResponseBodiesResult) {
         responses[key] = {
           description: httpStatusCodes_default[key],
           content: contentResolver(
             schemaValidator,
-            route.contractDetails.responses[key]
+            discriminatedResponseBodiesResult[key].schema,
+            discriminatedResponseBodiesResult[key].contentType
           )
         };
       }
+      const commonErrors = [400, 404, 500];
+      for (const error of commonErrors) {
+        if (!(error in responses)) {
+          responses[error] = {
+            description: httpStatusCodes_default[error],
+            content: contentResolver(schemaValidator, schemaValidator.string)
+          };
+        }
+      }
       const pathItemObject = {
         tags: [controllerName],
         summary: `${name}: ${summary}`,
@@ -2482,11 +2760,15 @@ function generateSwaggerDocument(schemaValidator, port, routers) {
           });
         }
       }
-      const body = route.contractDetails.body;
-      if (body) {
+      const discriminatedBodyResult = "body" in route.contractDetails ? discriminateBody(schemaValidator, route.contractDetails.body) : null;
+      if (discriminatedBodyResult) {
         pathItemObject.requestBody = {
           required: true,
-          content: contentResolver(schemaValidator, body)
+          content: contentResolver(
+            schemaValidator,
+            discriminatedBodyResult.schema,
+            discriminatedBodyResult.contentType
+          )
         };
       }
       if (requestHeaders) {
@@ -2569,6 +2851,8 @@ function metricsDefinitions(metrics2) {
   HTTPStatuses,
   OpenTelemetryCollector,
   delete_,
+  discriminateBody,
+  discriminateResponseBodies,
   enrichExpressLikeSend,
   evaluateTelemetryOptions,
   generateSwaggerDocument,