feat: configurable status codes

Author: astahmer

packages/typed-openapi/src/generator.ts

@@ -7,9 +7,16 @@ import { match } from "ts-pattern";
 import { type } from "arktype";
 import { wrapWithQuotesIfNeeded } from "./string-utils.ts";
 
+// Default success status codes (2xx and 3xx ranges)
+export const DEFAULT_SUCCESS_STATUS_CODES = [
+  200, 201, 202, 203, 204, 205, 206, 207, 208, 226,
+  300, 301, 302, 303, 304, 305, 306, 307, 308
+] as const;
+
 type GeneratorOptions = ReturnType<typeof mapOpenApiEndpoints> & {
   runtime?: "none" | keyof typeof runtimeValidationGenerator;
   schemasOnly?: boolean;
+  successStatusCodes?: readonly number[];
 };
 type GeneratorContext = Required<GeneratorOptions>;
 
@@ -60,7 +67,11 @@ const replacerByRuntime = {
 };
 
 export const generateFile = (options: GeneratorOptions) => {
-  const ctx = { ...options, runtime: options.runtime ?? "none" } as GeneratorContext;
+  const ctx = { 
+    ...options, 
+    runtime: options.runtime ?? "none",
+    successStatusCodes: options.successStatusCodes ?? DEFAULT_SUCCESS_STATUS_CODES
+  } as GeneratorContext;
 
   const schemaList = generateSchemaList(ctx);
   const endpointSchemaList = options.schemasOnly ? "" : generateEndpointSchemaList(ctx);
@@ -276,6 +287,13 @@ const generateApiClient = (ctx: GeneratorContext) => {
   const byMethods = groupBy(endpointList, "method");
   const endpointSchemaList = generateEndpointByMethod(ctx);
 
+  // Generate the StatusCode type from the configured success status codes
+  const generateStatusCodeType = (statusCodes: readonly number[]) => {
+    return statusCodes.join(" | ");
+  };
+
+  const statusCodeType = generateStatusCodeType(ctx.successStatusCodes);
+
   const apiClientTypes = `
 // <ApiClientTypes>
 export type EndpointParameters = {
@@ -315,6 +333,9 @@ export type Endpoint<TConfig extends DefaultEndpoint = DefaultEndpoint> = {
 
 export type Fetcher = (method: Method, url: string, parameters?: EndpointParameters | undefined) => Promise<Response>;
 
+// Status code type for success responses
+export type StatusCode = ${statusCodeType};
+
 // Error handling types
 export type ApiResponse<TSuccess, TAllResponses extends Record<string | number, unknown> = {}> = 
   (keyof TAllResponses extends never
@@ -325,21 +346,21 @@ export type ApiResponse<TSuccess, TAllResponses extends Record<string | number,
       }
     : {
         [K in keyof TAllResponses]: K extends string
-          ? K extends \`\${infer StatusCode extends number}\`
-            ? StatusCode extends 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226 | 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308
+          ? K extends \`\${infer TStatusCode extends number}\`
+            ? TStatusCode extends StatusCode
               ? {
                   ok: true;
-                  status: StatusCode;
+                  status: TStatusCode;
                   data: TAllResponses[K];
                 }
               : {
                   ok: false;
-                  status: StatusCode;
+                  status: TStatusCode;
                   error: TAllResponses[K];
                 }
             : never
           : K extends number
-            ? K extends 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226 | 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308
+            ? K extends StatusCode
               ? {
                   ok: true;
                   status: K;

packages/typed-openapi/tests/configurable-status-codes.test.ts

@@ -0,0 +1,67 @@
+import { it, expect } from "vitest";
+import type { OpenAPIObject } from "openapi3-ts/oas31";
+
+import { generateFile } from "../src/generator.ts";
+import { mapOpenApiEndpoints } from "../src/map-openapi-endpoints.ts";
+import { prettify } from "../src/format.ts";
+
+it("should use custom success status codes", async () => {
+  const openApiDoc: OpenAPIObject = {
+    openapi: "3.0.0",
+    info: { title: "Test API", version: "1.0.0" },
+    paths: {
+      "/test": {
+        get: {
+          operationId: "getTest",
+          responses: {
+            200: {
+              description: "Success",
+              content: {
+                "application/json": {
+                  schema: { type: "object", properties: { message: { type: "string" } } }
+                }
+              }
+            },
+            201: {
+              description: "Created", 
+              content: {
+                "application/json": {
+                  schema: { type: "object", properties: { id: { type: "string" } } }
+                }
+              }
+            },
+            400: {
+              description: "Bad Request",
+              content: {
+                "application/json": {
+                  schema: { type: "object", properties: { error: { type: "string" } } }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+
+  const endpoints = mapOpenApiEndpoints(openApiDoc);
+  
+  // Test with default success status codes (should include 200 and 201)
+  const defaultGenerated = await prettify(generateFile(endpoints));
+  expect(defaultGenerated).toContain("export type StatusCode =");
+  expect(defaultGenerated).toContain("| 200");
+  expect(defaultGenerated).toContain("| 201");
+  
+  // Test with custom success status codes (only 200)
+  const customGenerated = await prettify(generateFile({
+    ...endpoints,
+    successStatusCodes: [200] as const
+  }));
+  
+  // Should only contain 200 in the StatusCode type
+  expect(customGenerated).toContain("export type StatusCode = 200;");
+  expect(customGenerated).not.toContain("| 201");
+  
+  // The ApiResponse type should use the custom StatusCode
+  expect(customGenerated).toContain("TStatusCode extends StatusCode");
+});