ts-typed-api 0.1.0 → 0.1.2

package/src/definition.ts

@@ -95,6 +95,8 @@ export function CreateResponses<TInputMap extends Partial<Record<AllowedInputSta
                     });
                 } else if (schemaOrMarker instanceof ZodType) { // It's a Zod schema
                     (builtResult as any)[numericKey] = createSuccessUnifiedResponseSchema(schemaOrMarker);
+                } else {
+                    (builtResult as any)[numericKey] = createSuccessUnifiedResponseSchema(schemaOrMarker);
                 }
                 // Note: If schemaOrMarker is something else, it would be a type error
                 // based on InputSchemaOrMarker, or this runtime check would skip it.
@@ -109,6 +111,35 @@ export function CreateResponses<TInputMap extends Partial<Record<AllowedInputSta
     return builtResult as CreateResponsesReturnType<TInputMap>;
 }
 
+// File upload configuration interface
+export interface FileUploadConfig {
+    // Single file upload
+    single?: {
+        fieldName: string;
+        maxSize?: number; // in bytes
+        allowedMimeTypes?: string[];
+    };
+    // Multiple files upload (same field name)
+    array?: {
+        fieldName: string;
+        maxCount?: number;
+        maxSize?: number; // in bytes per file
+        allowedMimeTypes?: string[];
+    };
+    // Multiple files upload (different field names)
+    fields?: Array<{
+        fieldName: string;
+        maxCount?: number;
+        maxSize?: number; // in bytes per file
+        allowedMimeTypes?: string[];
+    }>;
+    // Any files upload
+    any?: {
+        maxSize?: number; // in bytes per file
+        allowedMimeTypes?: string[];
+    };
+}
+
 // Define the structure for a single API route
 export interface RouteSchema {
     path: string;
@@ -116,6 +147,7 @@ export interface RouteSchema {
     params?: ZodTypeAny;
     query?: ZodTypeAny;
     body?: ZodTypeAny;
+    fileUpload?: FileUploadConfig; // Optional file upload configuration
     responses: Record<number, ZodTypeAny>; // Maps HTTP status codes to Zod schemas
 }
 
@@ -229,3 +261,68 @@ export type ApiClientQuery<
 > = TDef['endpoints'][TDomain][TRouteName] extends { query: infer Q extends ZodTypeAny }
     ? z.input<Q> // Use z.input for the type expected by the client to send
     : undefined;
+
+// --- File Upload Validation Schemas ---
+
+// Schema for validating uploaded files
+export const fileSchema = z.object({
+    fieldname: z.string(),
+    originalname: z.string(),
+    encoding: z.string(),
+    mimetype: z.string(),
+    size: z.number(),
+    buffer: z.instanceof(Buffer),
+    destination: z.string().optional(),
+    filename: z.string().optional(),
+    path: z.string().optional(),
+    stream: z.any().optional(),
+});
+
+export type FileType = z.infer<typeof fileSchema>;
+
+// Helper function to create file validation schema with constraints
+export function createFileValidationSchema(options?: {
+    maxSize?: number;
+    allowedMimeTypes?: string[];
+    required?: boolean;
+}) {
+    let schema: z.ZodTypeAny = fileSchema;
+
+    if (options?.maxSize) {
+        schema = schema.refine(
+            (file: any) => file.size <= options.maxSize!,
+            { message: `File size must be less than ${options.maxSize} bytes` }
+        );
+    }
+
+    if (options?.allowedMimeTypes && options.allowedMimeTypes.length > 0) {
+        schema = schema.refine(
+            (file: any) => options.allowedMimeTypes!.includes(file.mimetype),
+            { message: `File type must be one of: ${options.allowedMimeTypes.join(', ')}` }
+        );
+    }
+
+    return options?.required === false ? schema.optional() : schema;
+}
+
+// Helper function to create array of files validation schema
+export function createFilesArrayValidationSchema(options?: {
+    maxCount?: number;
+    maxSize?: number;
+    allowedMimeTypes?: string[];
+    required?: boolean;
+}) {
+    const singleFileSchema = createFileValidationSchema({
+        maxSize: options?.maxSize,
+        allowedMimeTypes: options?.allowedMimeTypes,
+        required: true, // Individual files in array are required
+    });
+
+    let schema = z.array(singleFileSchema);
+
+    if (options?.maxCount) {
+        schema = schema.max(options.maxCount, `Maximum ${options.maxCount} files allowed`);
+    }
+
+    return options?.required === false ? schema.optional() : schema;
+}

package/src/handler.ts

@@ -1,7 +1,8 @@
 import { z } from "zod";
-import { ApiDefinitionSchema, RouteSchema, UnifiedError } from "./definition";
+import { ApiDefinitionSchema, RouteSchema, UnifiedError, FileUploadConfig } from "./definition";
 import { createRouteHandler, TypedRequest, TypedResponse } from "./router";
 import express from "express";
+import multer from "multer";
 
 // A handler entry, now generic over TDef
 export type SpecificRouteHandler<TDef extends ApiDefinitionSchema> = {
@@ -20,6 +21,151 @@ type EndpointMiddleware = (
     endpointInfo: { domain: string; routeKey: string }
 ) => void | Promise<void>;
 
+// Helper function to create multer middleware based on file upload configuration
+function createFileUploadMiddleware(config: FileUploadConfig): express.RequestHandler {
+    // Default multer configuration
+    const storage = multer.memoryStorage(); // Store files in memory by default
+
+    let multerMiddleware: express.RequestHandler;
+
+    if (config.single) {
+        const upload = multer({
+            storage,
+            limits: {
+                fileSize: config.single.maxSize || 10 * 1024 * 1024, // Default 10MB
+            },
+            fileFilter: (req, file, cb) => {
+                if (config.single!.allowedMimeTypes && !config.single!.allowedMimeTypes.includes(file.mimetype)) {
+                    cb(new Error(`File type ${file.mimetype} not allowed`));
+                    return;
+                }
+                cb(null, true);
+            }
+        });
+        multerMiddleware = upload.single(config.single.fieldName);
+    } else if (config.array) {
+        const upload = multer({
+            storage,
+            limits: {
+                fileSize: config.array.maxSize || 10 * 1024 * 1024, // Default 10MB per file
+                files: config.array.maxCount || 10, // Default max 10 files
+            },
+            fileFilter: (req, file, cb) => {
+                if (config.array!.allowedMimeTypes && !config.array!.allowedMimeTypes.includes(file.mimetype)) {
+                    cb(new Error(`File type ${file.mimetype} not allowed`));
+                    return;
+                }
+                cb(null, true);
+            }
+        });
+        multerMiddleware = upload.array(config.array.fieldName, config.array.maxCount);
+    } else if (config.fields) {
+        const upload = multer({
+            storage,
+            limits: {
+                fileSize: Math.max(...config.fields.map(f => f.maxSize || 10 * 1024 * 1024)), // Use max size from all fields
+            },
+            fileFilter: (req, file, cb) => {
+                const fieldConfig = config.fields!.find(f => f.fieldName === file.fieldname);
+                if (fieldConfig?.allowedMimeTypes && !fieldConfig.allowedMimeTypes.includes(file.mimetype)) {
+                    cb(new Error(`File type ${file.mimetype} not allowed for field ${file.fieldname}`));
+                    return;
+                }
+                cb(null, true);
+            }
+        });
+        const fields = config.fields.map(f => ({ name: f.fieldName, maxCount: f.maxCount || 1 }));
+        multerMiddleware = upload.fields(fields);
+    } else if (config.any) {
+        const upload = multer({
+            storage,
+            limits: {
+                fileSize: config.any.maxSize || 10 * 1024 * 1024, // Default 10MB per file
+            },
+            fileFilter: (req, file, cb) => {
+                if (config.any!.allowedMimeTypes && !config.any!.allowedMimeTypes.includes(file.mimetype)) {
+                    cb(new Error(`File type ${file.mimetype} not allowed`));
+                    return;
+                }
+                cb(null, true);
+            }
+        });
+        multerMiddleware = upload.any();
+    } else {
+        // Fallback - should not reach here if config is valid
+        throw new Error('Invalid file upload configuration');
+    }
+
+    // Wrap multer middleware with error handling to format errors as 422 JSON responses
+    return (req: express.Request, res: express.Response, next: express.NextFunction) => {
+        multerMiddleware(req, res, (error) => {
+            if (error) {
+                // Convert multer errors to UnifiedError format
+                const mappedErrors: UnifiedError = [];
+
+                if (error instanceof multer.MulterError) {
+                    let errorMessage = error.message;
+                    let fieldName = 'file';
+
+                    switch (error.code) {
+                        case 'LIMIT_FILE_SIZE':
+                            errorMessage = 'File size exceeds the allowed limit';
+                            break;
+                        case 'LIMIT_FILE_COUNT':
+                            errorMessage = 'Too many files uploaded';
+                            break;
+                        case 'LIMIT_UNEXPECTED_FILE':
+                            errorMessage = `Unexpected field: ${error.field}`;
+                            fieldName = error.field || 'file';
+                            break;
+                        case 'LIMIT_FIELD_KEY':
+                            errorMessage = 'Field name too long';
+                            break;
+                        case 'LIMIT_FIELD_VALUE':
+                            errorMessage = 'Field value too long';
+                            break;
+                        case 'LIMIT_FIELD_COUNT':
+                            errorMessage = 'Too many fields';
+                            break;
+                        case 'LIMIT_PART_COUNT':
+                            errorMessage = 'Too many parts';
+                            break;
+                        default:
+                            errorMessage = error.message || 'File upload error';
+                    }
+
+                    mappedErrors.push({
+                        field: fieldName,
+                        message: errorMessage,
+                        type: 'body',
+                    });
+                } else if (error instanceof Error) {
+                    // Handle custom errors from fileFilter
+                    mappedErrors.push({
+                        field: 'file',
+                        message: error.message,
+                        type: 'body',
+                    });
+                } else {
+                    mappedErrors.push({
+                        field: 'file',
+                        message: 'File upload error',
+                        type: 'body',
+                    });
+                }
+
+                // Send 422 response with structured error format
+                res.status(422).json({
+                    data: null,
+                    error: mappedErrors
+                });
+            } else {
+                next();
+            }
+        });
+    };
+}
+
 // Register route handlers with Express, now generic over TDef
 export function registerRouteHandlers<TDef extends ApiDefinitionSchema>(
     app: express.Express,
@@ -192,6 +338,18 @@ export function registerRouteHandlers<TDef extends ApiDefinitionSchema>(
 
         // Create middleware wrappers that include endpoint information
         const middlewareWrappers: express.RequestHandler[] = [];
+
+        // Add file upload middleware if configured
+        if (routeDefinition.fileUpload) {
+            try {
+                const fileUploadMiddleware = createFileUploadMiddleware(routeDefinition.fileUpload);
+                middlewareWrappers.push(fileUploadMiddleware);
+            } catch (error) {
+                console.error(`Error creating file upload middleware for ${currentDomain}.${currentRouteKey}:`, error);
+                return; // Skip this route if file upload middleware creation fails
+            }
+        }
+
         if (middlewares && middlewares.length > 0) {
             middlewares.forEach(middleware => {
                 const wrappedMiddleware: express.RequestHandler = async (req, res, next) => {

package/src/index.ts

@@ -1,4 +1,5 @@
 export { ApiClient, FetchHttpClientAdapter } from './client';
 export { CreateApiDefinition, CreateResponses } from './definition';
 export { RegisterHandlers, EndpointMiddleware } from './object-handlers';
+export { File as UploadedFile } from './router';
 export { z as ZodSchema } from 'zod';

package/src/router.ts

@@ -7,6 +7,9 @@ import {
     InferDataFromUnifiedResponse,
 } from './definition';
 
+// Define the file type based on Express.Multer namespace
+export type File = Express.Multer.File;
+
 // Typed Request for Express handlers, now generic over TDef
 export type TypedRequest<
     TDef extends ApiDefinitionSchema,
@@ -17,7 +20,11 @@ export type TypedRequest<
     ReqBody extends ApiBody<TDef, TDomain, TRouteKey> = ApiBody<TDef, TDomain, TRouteKey>,
     Q extends ApiQuery<TDef, TDomain, TRouteKey> = ApiQuery<TDef, TDomain, TRouteKey>,
     L extends Record<string, any> = Record<string, any>
-> = express.Request<P, any, ReqBody, Q, L>
+> = express.Request<P, any, ReqBody, Q, L> & {
+    // Add file upload support
+    file?: File;
+    files?: File[] | { [fieldname: string]: File[] };
+}
 
 // --- Enhanced TypedResponse with res.respond, now generic over TDef ---
 

package/dist/apiClient.d.ts

@@ -1,147 +0,0 @@
-import { type ApiDefinitionSchema as BaseApiDefinitionSchema, // Renamed for clarity
-type ApiRouteKey, type ApiClientParams, type ApiClientQuery, type ApiClientBody, type RouteSchema, type UnifiedError, type InferDataFromUnifiedResponse } from "./router/definition";
-import { type ZodTypeAny } from 'zod';
-/**
- * Options for an HTTP request made by an adapter.
- */
-export interface HttpRequestOptions {
-    method: RouteSchema['method'];
-    headers?: Record<string, string>;
-    body?: string | FormData;
-}
-/**
- * Represents an HTTP response from an adapter.
- * @template T The expected type of the JSON body.
- */
-export interface HttpResponse<T = any> {
-    status: number;
-    headers: Headers;
-    json(): Promise<T>;
-    text(): Promise<string>;
-    /**
-     * Gets the underlying raw response object from the adapter (e.g., Fetch API's Response object).
-     * The type of this object depends on the adapter implementation.
-     */
-    getRawResponse(): any;
-}
-/**
- * Interface for an HTTP client adapter.
- * Allows swapping out the underlying HTTP request mechanism (e.g., fetch, axios).
- */
-export interface HttpClientAdapter {
-    /**
-     * Makes an HTTP request.
-     * @template T The expected type of the JSON response body.
-     * @param url The URL to request.
-     * @param options The request options.
-     * @returns A promise that resolves to an HttpResponse.
-     */
-    request<T = any>(url: string, options: HttpRequestOptions): Promise<HttpResponse<T>>;
-}
-/**
- * An HttpClientAdapter implementation that uses the native Fetch API.
- */
-export declare class FetchHttpClientAdapter implements HttpClientAdapter {
-    request<T = any>(url: string, options: HttpRequestOptions): Promise<HttpResponse<T>>;
-}
-type GetRoute<TActualDef extends BaseApiDefinitionSchema, TDomain extends keyof TActualDef, K extends ApiRouteKey<TActualDef, TDomain>> = TActualDef[TDomain][K] extends infer Rte ? Rte extends RouteSchema ? Rte : never : never;
-type GetResponses<Rte extends RouteSchema> = Rte['responses'];
-/**
- * Discriminated union type for the result of callApi.
- * @template TDef The specific ApiDefinition structure being used.
- * @template TDomain The domain (controller) of the API.
- * @template TRouteKey The key of the route within the domain.
- */
-type ApiCallResultPayload<S_STATUS_NUM extends number, ActualSchema extends ZodTypeAny> = S_STATUS_NUM extends 422 ? {
-    status: S_STATUS_NUM;
-    error: UnifiedError;
-    rawResponse: any;
-    data?: undefined;
-} : S_STATUS_NUM extends 204 ? {
-    status: S_STATUS_NUM;
-    data: void;
-    rawResponse: any;
-    error?: undefined;
-} : {
-    status: S_STATUS_NUM;
-    data: InferDataFromUnifiedResponse<ActualSchema>;
-    rawResponse: any;
-    error?: undefined;
-};
-export type ApiCallResult<TActualDef extends BaseApiDefinitionSchema, TDomain extends keyof TActualDef, TRouteKey extends ApiRouteKey<TActualDef, TDomain>, CurrentRoute extends RouteSchema = GetRoute<TActualDef, TDomain, TRouteKey>, ResponsesMap = GetResponses<CurrentRoute>> = ResponsesMap extends Record<any, ZodTypeAny> ? {
-    [S_STATUS_NUM in keyof ResponsesMap]: S_STATUS_NUM extends number ? ResponsesMap[S_STATUS_NUM] extends infer ActualSchema extends ZodTypeAny ? ApiCallResultPayload<S_STATUS_NUM, ActualSchema> : never : never;
-}[keyof ResponsesMap] : never;
-/**
- * Options for the callApi method.
- * @template TDef The specific ApiDefinition structure being used.
- * @template TDomainParam The domain (controller) of the API.
- * @template TRouteKeyParam The key of the route within the domain.
- */
-export type CallApiOptions<TActualDef extends BaseApiDefinitionSchema, // Made generic over TActualDef
-TDomainParam extends keyof TActualDef, TRouteKeyParam extends ApiRouteKey<TActualDef, TDomainParam>> = {
-    params?: ApiClientParams<TActualDef, TDomainParam, TRouteKeyParam>;
-    query?: ApiClientQuery<TActualDef, TDomainParam, TRouteKeyParam>;
-    body?: ApiClientBody<TActualDef, TDomainParam, TRouteKeyParam>;
-    headers?: Record<string, string>;
-};
-/**
- * A client for making API calls defined by an ApiDefinition.
- * It uses an HttpClientAdapter for making actual HTTP requests and supports persistent headers.
- */
-export declare class ApiClient<TActualDef extends BaseApiDefinitionSchema> {
-    private baseUrl;
-    private apiDefinitionObject;
-    private adapter;
-    private persistentHeaders;
-    /**
-     * Creates an instance of ApiClient.
-     * @param baseUrl The base URL for all API calls (e.g., 'http://localhost:3001').
-     * @param apiDefinitionObject The API definition object.
-     * @param adapter An instance of HttpClientAdapter to use for requests.
-     */
-    constructor(baseUrl: string, apiDefinitionObject: TActualDef, // Parameter uses TActualDef
-    adapter: HttpClientAdapter);
-    /**
-     * Sets a persistent header that will be included in all subsequent API calls.
-     * If the header already exists, its value will be updated.
-     * @param name The name of the header.
-     * @param value The value of the header.
-     */
-    setHeader(name: string, value: string): void;
-    /**
-     * Gets the value of a persistent header.
-     * @param name The name of the header.
-     * @returns The value of the header, or undefined if not set.
-     */
-    getHeader(name: string): string | undefined;
-    /**
-     * Removes a persistent header.
-     * @param name The name of the header to remove.
-     */
-    removeHeader(name: string): void;
-    /**
-     * Clears all persistent headers.
-     */
-    clearHeaders(): void;
-    /**
-     * Makes an API call to a specified domain and route.
-     * @template TDomain The domain (controller) of the API.
-     * @template TRouteKey The key of the route within the domain.
-     * @template TInferredHandlers A type inferred from the handlers object, ensuring all defined statuses are handled.
-     * @param domain The API domain (e.g., 'user').
-     * @param routeKey The API route key (e.g., 'getUsers').
-     * @param callData Optional parameters, query, body, and headers for the request.
-     * @param handlers An object where keys are status codes and values are handler functions for those statuses.
-     * @returns A promise that resolves to the return value of the executed handler.
-     * @throws Error if the route configuration is invalid, a network error occurs, an unhandled status code is received, or JSON parsing fails.
-     */
-    callApi<TDomain extends keyof TActualDef, TRouteKey extends ApiRouteKey<TActualDef, TDomain>, TInferredHandlers extends {
-        [KStatus in ApiCallResult<TActualDef, TDomain, TRouteKey>['status']]: (payload: Extract<ApiCallResult<TActualDef, TDomain, TRouteKey>, {
-            status: KStatus;
-        }>) => any;
-    }>(domain: TDomain, routeKey: TRouteKey, callData: CallApiOptions<TActualDef, TDomain, TRouteKey> | undefined, // Uses TActualDef
-    handlers: TInferredHandlers): Promise<{
-        [SKey in keyof TInferredHandlers]: TInferredHandlers[SKey] extends (...args: any[]) => infer R ? R : never;
-    }[keyof TInferredHandlers]>;
-}
-export {};

package/dist/apiClient.js

@@ -1,206 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiClient = exports.FetchHttpClientAdapter = void 0;
-// --- Fetch Implementation of the Adapter ---
-/**
- * An HttpClientAdapter implementation that uses the native Fetch API.
- */
-class FetchHttpClientAdapter {
-    async request(url, options) {
-        const fetchOptions = {
-            method: options.method,
-            headers: options.headers,
-            // Note: `credentials` (e.g., 'include' for cookies) is not set by default.
-            // It can be configured by extending this adapter or by managing cookies via the 'Cookie' header.
-        };
-        if (options.body !== undefined) {
-            fetchOptions.body = options.body;
-        }
-        const nativeFetchResponse = await fetch(url, fetchOptions);
-        return {
-            status: nativeFetchResponse.status,
-            headers: nativeFetchResponse.headers,
-            json: () => nativeFetchResponse.json(),
-            text: () => nativeFetchResponse.text(),
-            getRawResponse: () => nativeFetchResponse,
-        };
-    }
-}
-exports.FetchHttpClientAdapter = FetchHttpClientAdapter;
-// --- API Client Class ---
-/**
- * A client for making API calls defined by an ApiDefinition.
- * It uses an HttpClientAdapter for making actual HTTP requests and supports persistent headers.
- */
-class ApiClient {
-    baseUrl;
-    apiDefinitionObject; // Uses generic type TActualDef
-    adapter;
-    persistentHeaders = {};
-    /**
-     * Creates an instance of ApiClient.
-     * @param baseUrl The base URL for all API calls (e.g., 'http://localhost:3001').
-     * @param apiDefinitionObject The API definition object.
-     * @param adapter An instance of HttpClientAdapter to use for requests.
-     */
-    constructor(baseUrl, apiDefinitionObject, // Parameter uses TActualDef
-    adapter) {
-        this.baseUrl = baseUrl.replace(/\/$/, ''); // Remove trailing slash
-        this.apiDefinitionObject = apiDefinitionObject;
-        this.adapter = adapter;
-    }
-    /**
-     * Sets a persistent header that will be included in all subsequent API calls.
-     * If the header already exists, its value will be updated.
-     * @param name The name of the header.
-     * @param value The value of the header.
-     */
-    setHeader(name, value) {
-        this.persistentHeaders[name] = value;
-    }
-    /**
-     * Gets the value of a persistent header.
-     * @param name The name of the header.
-     * @returns The value of the header, or undefined if not set.
-     */
-    getHeader(name) {
-        return this.persistentHeaders[name];
-    }
-    /**
-     * Removes a persistent header.
-     * @param name The name of the header to remove.
-     */
-    removeHeader(name) {
-        delete this.persistentHeaders[name];
-    }
-    /**
-     * Clears all persistent headers.
-     */
-    clearHeaders() {
-        this.persistentHeaders = {};
-    }
-    /**
-     * Makes an API call to a specified domain and route.
-     * @template TDomain The domain (controller) of the API.
-     * @template TRouteKey The key of the route within the domain.
-     * @template TInferredHandlers A type inferred from the handlers object, ensuring all defined statuses are handled.
-     * @param domain The API domain (e.g., 'user').
-     * @param routeKey The API route key (e.g., 'getUsers').
-     * @param callData Optional parameters, query, body, and headers for the request.
-     * @param handlers An object where keys are status codes and values are handler functions for those statuses.
-     * @returns A promise that resolves to the return value of the executed handler.
-     * @throws Error if the route configuration is invalid, a network error occurs, an unhandled status code is received, or JSON parsing fails.
-     */
-    async callApi(domain, routeKey, callData, // Uses TActualDef
-    handlers) {
-        const routeInfo = this.apiDefinitionObject[domain][routeKey]; // Accessing from TActualDef instance
-        if (!routeInfo || typeof routeInfo.path !== 'string') {
-            throw new Error(`API route configuration ${String(domain)}.${String(routeKey)} not found or invalid.`);
-        }
-        let urlPath = routeInfo.path;
-        if (callData?.params) {
-            const params = callData.params;
-            for (const key in params) {
-                if (Object.prototype.hasOwnProperty.call(params, key) && params[key] !== undefined) {
-                    urlPath = urlPath.replace(`:${key}`, String(params[key]));
-                }
-            }
-        }
-        const url = new URL(this.baseUrl + urlPath);
-        if (callData?.query) {
-            const queryParams = callData.query;
-            for (const key in queryParams) {
-                if (Object.prototype.hasOwnProperty.call(queryParams, key) && queryParams[key] !== undefined) {
-                    url.searchParams.append(key, String(queryParams[key]));
-                }
-            }
-        }
-        const requestHeaders = {
-            ...this.persistentHeaders,
-            'Content-Type': 'application/json',
-            ...(callData?.headers || {}),
-        };
-        const adapterRequestOptions = {
-            method: routeInfo.method,
-            headers: requestHeaders,
-        };
-        if (routeInfo.method !== 'GET' && routeInfo.method !== 'HEAD' && callData?.body !== undefined) {
-            adapterRequestOptions.body = JSON.stringify(callData.body);
-        }
-        let adapterResponse;
-        try {
-            adapterResponse = await this.adapter.request(url.toString(), adapterRequestOptions);
-        }
-        catch (networkError) {
-            const errorMessage = networkError instanceof Error ? networkError.message : `Unknown network error calling API ${String(domain)}.${String(routeKey)}`;
-            console.error(`Network error for ${String(domain)}.${String(routeKey)}:`, networkError);
-            throw new Error(`Network error: ${errorMessage}`);
-        }
-        const runtimeStatus = adapterResponse.status;
-        const definedStatusCodes = Object.keys(routeInfo.responses).map(Number);
-        if (!definedStatusCodes.includes(runtimeStatus)) {
-            const responseText = await adapterResponse.text().catch(() => "Could not read response text.");
-            const errorMsg = `API ${String(domain)}.${String(routeKey)}: Received unhandled status code ${runtimeStatus}. Expected one of: ${definedStatusCodes.join(', ')}. Response: ${responseText}`;
-            console.error(errorMsg);
-            throw new Error(errorMsg);
-        }
-        const currentStatusLiteral = runtimeStatus;
-        // apiResultPayload now uses ApiCallResult with TActualDef
-        let apiResultPayload;
-        if (currentStatusLiteral === 204) {
-            apiResultPayload = {
-                status: 204,
-                data: undefined,
-                rawResponse: adapterResponse.getRawResponse(),
-            };
-        }
-        else {
-            let responseBodyJson;
-            const contentType = adapterResponse.headers.get("content-type");
-            if (contentType && contentType.includes("application/json")) {
-                try {
-                    responseBodyJson = await adapterResponse.json();
-                }
-                catch (e) {
-                    const parseErrorMsg = `API ${String(domain)}.${String(routeKey)}: Failed to parse JSON for status ${currentStatusLiteral}. Error: ${e instanceof Error ? e.message : String(e)}`;
-                    console.error(parseErrorMsg, adapterResponse.getRawResponse());
-                    throw new Error(parseErrorMsg);
-                }
-            }
-            else if (runtimeStatus >= 400) { // Handle non-JSON error responses
-                const responseText = await adapterResponse.text().catch(() => "Could not read response text.");
-                if (currentStatusLiteral === 422) { // Try to conform to UnifiedError for 422
-                    responseBodyJson = {
-                        error: [{ field: 'general', type: 'general', message: `Non-JSON error response for 422: ${responseText}` }] // Adjusted: type to 'general'
-                    };
-                }
-                else { // For other non-JSON errors, data will likely be undefined. Log a warning.
-                    console.warn(`API ${String(domain)}.${String(routeKey)}: Received non-JSON response for status ${currentStatusLiteral}. Response: ${responseText}`);
-                    // responseBodyJson remains undefined or as is, data extraction below will handle it.
-                }
-            }
-            if (currentStatusLiteral === 422) {
-                const errorData = responseBodyJson?.error || [{ field: 'general', type: 'general', message: `HTTP error 422: ${await adapterResponse.text().catch(() => 'Unknown error text')}` }];
-                // Assign directly to apiResultPayload, relying on its type ApiCallResult<TActualDef, TDomain, TRouteKey>
-                // to correctly match the 422 variant.
-                apiResultPayload = {
-                    status: 422,
-                    error: errorData,
-                    rawResponse: adapterResponse.getRawResponse(),
-                }; // Force cast via unknown
-            }
-            else {
-                // Assuming responseBodyJson is an object like { data: <actual_payload> }
-                // as per backend contract for non-204/non-422 responses.
-                apiResultPayload = {
-                    status: currentStatusLiteral,
-                    data: responseBodyJson.data,
-                    rawResponse: adapterResponse.getRawResponse(),
-                };
-            }
-        }
-        const handler = handlers[apiResultPayload.status];
-        return handler(apiResultPayload); // Reverting to `as any` as TS struggles with direct narrowing here
-    }
-}
-exports.ApiClient = ApiClient;