Exposing the expected request content type (#1739)

This should enable connecting uploader/raw parsers only to the endpoints
that really need it (initRouting).
Then can revert #1733

src/common-helpers.ts

@@ -8,14 +8,14 @@ import { InputValidationError, OutputValidationError } from "./errors";
 import { AbstractLogger } from "./logger";
 import { getMeta } from "./metadata";
 import { AuxMethod, Method } from "./method";
-import { mimeMultipart } from "./mime";
+import { contentTypes } from "./content-type";
 
 export type FlatObject = Record<string, unknown>;
 
 const areFilesAvailable = (request: Request): boolean => {
   const contentType = request.header("content-type") || "";
-  const isMultipart = contentType.toLowerCase().startsWith(mimeMultipart);
-  return "files" in request && isMultipart;
+  const isUpload = contentType.toLowerCase().startsWith(contentTypes.upload);
+  return "files" in request && isUpload;
 };
 
 export const defaultInputSources: InputSources = {

src/content-type.ts

@@ -0,0 +1,7 @@
+export const contentTypes = {
+  json: "application/json",
+  upload: "multipart/form-data",
+  raw: "application/octet-stream",
+};
+
+export type ContentType = keyof typeof contentTypes;

src/endpoint.ts

@@ -26,7 +26,7 @@ import { AbstractLogger } from "./logger";
 import { LogicalContainer, combineContainers } from "./logical-container";
 import { AuxMethod, Method } from "./method";
 import { AnyMiddlewareDef } from "./middleware";
-import { mimeJson, mimeMultipart, mimeRaw } from "./mime";
+import { ContentType, contentTypes } from "./content-type";
 import { AnyResultHandlerDefinition } from "./result-handler";
 import { Security } from "./security";
 
@@ -61,6 +61,7 @@ export abstract class AbstractEndpoint {
   public abstract getScopes(): string[];
   public abstract getTags(): string[];
   public abstract getOperationId(method: Method): string | undefined;
+  public abstract getRequestType(): ContentType;
 }
 
 export class Endpoint<
@@ -81,6 +82,7 @@ export class Endpoint<
   readonly #scopes: SCO[];
   readonly #tags: TAG[];
   readonly #getOperationId: (method: Method) => string | undefined;
+  readonly #requestType: ContentType;
 
   constructor({
     methods,
@@ -128,10 +130,13 @@ export class Endpoint<
     this.#responses = {
       positive: normalizeApiResponse(
         resultHandler.getPositiveResponse(outputSchema),
-        { mimeTypes: [mimeJson], statusCodes: [defaultStatusCodes.positive] },
+        {
+          mimeTypes: [contentTypes.json],
+          statusCodes: [defaultStatusCodes.positive],
+        },
       ),
       negative: normalizeApiResponse(resultHandler.getNegativeResponse(), {
-        mimeTypes: [mimeJson],
+        mimeTypes: [contentTypes.json],
         statusCodes: [defaultStatusCodes.negative],
       }),
     };
@@ -143,12 +148,13 @@ export class Endpoint<
         ),
       );
     }
+    this.#requestType = hasUpload(inputSchema)
+      ? "upload"
+      : hasRaw(inputSchema)
+        ? "raw"
+        : "json";
     this.#mimeTypes = {
-      input: hasUpload(inputSchema)
-        ? [mimeMultipart]
-        : hasRaw(inputSchema)
-          ? [mimeRaw]
-          : [mimeJson],
+      input: [contentTypes[this.#requestType]],
       positive: this.#responses.positive.flatMap(({ mimeTypes }) => mimeTypes),
       negative: this.#responses.negative.flatMap(({ mimeTypes }) => mimeTypes),
     };
@@ -178,6 +184,10 @@ export class Endpoint<
     return this.#mimeTypes[variant];
   }
 
+  public override getRequestType() {
+    return this.#requestType;
+  }
+
   public override getResponses(variant: ResponseVariant) {
     return this.#responses[variant];
   }

src/integration.ts

@@ -29,7 +29,7 @@ import {
 } from "./integration-helpers";
 import { defaultSerializer, makeCleanId } from "./common-helpers";
 import { Method, methods } from "./method";
-import { mimeJson } from "./mime";
+import { contentTypes } from "./content-type";
 import { loadPeer } from "./peer-helpers";
 import { Routing } from "./routing";
 import { walkRouting } from "./routing-walker";
@@ -219,7 +219,9 @@ export class Integration {
               positive: positiveResponseId,
               negative: negativeResponseId,
               response: genericResponseId,
-              isJson: endpoint.getMimeTypes("positive").includes(mimeJson),
+              isJson: endpoint
+                .getMimeTypes("positive")
+                .includes(contentTypes.json),
               tags: endpoint.getTags(),
             },
           );
@@ -482,7 +484,7 @@ export class Integration {
         f.createObjectLiteralExpression([
           f.createPropertyAssignment(
             f.createStringLiteral("Content-Type"),
-            f.createStringLiteral(mimeJson),
+            f.createStringLiteral(contentTypes.json),
           ),
         ]),
         undefined,

src/testing.ts

@@ -3,7 +3,7 @@ import http from "node:http";
 import { CommonConfig } from "./config-type";
 import { AbstractEndpoint } from "./endpoint";
 import { AbstractLogger } from "./logger";
-import { mimeJson } from "./mime";
+import { contentTypes } from "./content-type";
 import { loadAlternativePeer } from "./peer-helpers";
 
 /**
@@ -25,7 +25,7 @@ export const makeRequestMock = <REQ extends Record<string, any>>({
 }) =>
   ({
     method: "GET",
-    header: fnMethod(() => mimeJson),
+    header: fnMethod(() => contentTypes.json),
     ...requestProps,
   }) as { method: string } & Record<"header", MockOverrides> & REQ;
 

tests/unit/content-type.spec.ts

@@ -0,0 +1,12 @@
+import { contentTypes } from "../../src/content-type";
+import { describe, expect, test } from "vitest";
+
+describe("contentTypes", () => {
+  test("should has predefined properties", () => {
+    expect(contentTypes).toEqual({
+      json: "application/json",
+      upload: "multipart/form-data",
+      raw: "application/octet-stream",
+    });
+  });
+});

tests/unit/documentation.spec.ts

@@ -11,7 +11,7 @@ import {
   ez,
 } from "../../src";
 import { expectType } from "tsd";
-import { mimeJson } from "../../src/mime";
+import { contentTypes } from "../../src/content-type";
 import { z } from "zod";
 import { givePort } from "../helpers";
 import { describe, expect, test, vi } from "vitest";
@@ -791,7 +791,7 @@ describe("Documentation", () => {
       const resultHandler = createResultHandler({
         getPositiveResponse: (output) => ({
           schema: z.object({ status: z.literal("OK"), result: output }),
-          mimeTypes: [mimeJson, "text/vnd.yaml"],
+          mimeTypes: [contentTypes.json, "text/vnd.yaml"],
           statusCode: 201,
         }),
         getNegativeResponse: () => ({

tests/unit/endpoint.spec.ts

@@ -365,6 +365,26 @@ describe("Endpoint", () => {
     );
   });
 
+  describe("getRequestType()", () => {
+    test.each([
+      { input: z.object({}), expected: "json" },
+      { input: ez.raw(), expected: "raw" },
+      { input: z.object({ file: ez.upload() }), expected: "upload" },
+    ])(
+      "should return the assigned one upon constructing",
+      ({ input, expected }) => {
+        const factory = new EndpointsFactory(defaultResultHandler);
+        const endpoint = factory.build({
+          method: "get",
+          input,
+          output: z.object({}),
+          handler: vi.fn(),
+        });
+        expect(endpoint.getRequestType()).toEqual(expected);
+      },
+    );
+  });
+
   describe(".getOperationId()", () => {
     test("should return undefined if its not defined upon creaton", () => {
       expect(