@taico/openapi-sdkgen 0.1.2 → 0.2.12

package/dist/generator.js

@@ -53,7 +53,7 @@ function schemaToTypeScript(schema) {
     let baseType;
     switch (schema.type) {
         case 'string':
-            baseType = 'string';
+            baseType = schema.format === 'binary' ? 'Blob' : 'string';
             break;
         case 'number':
         case 'integer':
@@ -104,9 +104,113 @@ export interface ClientConfig {
   headers?: Record<string, string>;
 }
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+function getErrorMessageFromBody(body: unknown): string | undefined {
+  if (!isRecord(body)) {
+    return undefined;
+  }
+
+  const detail = body.detail;
+  if (typeof detail === 'string' && detail.length > 0) {
+    return detail;
+  }
+
+  const message = body.message;
+  if (typeof message === 'string' && message.length > 0) {
+    return message;
+  }
+
+  const title = body.title;
+  if (typeof title === 'string' && title.length > 0) {
+    return title;
+  }
+
+  const errorDescription = body.error_description;
+  if (typeof errorDescription === 'string' && errorDescription.length > 0) {
+    return errorDescription;
+  }
+
+  return undefined;
+}
+
+export class ApiError extends Error {
+  public readonly status: number;
+  public readonly statusText: string;
+  public readonly body: unknown;
+
+  constructor(response: Response, body: unknown) {
+    const message = getErrorMessageFromBody(body) ?? \`HTTP \${response.status}: \${response.statusText}\`;
+    super(message);
+    this.name = 'ApiError';
+    this.status = response.status;
+    this.statusText = response.statusText;
+    this.body = body;
+  }
+}
+
 export class BaseClient {
   constructor(protected config: ClientConfig) {}
 
+  private async parseResponseBody(
+    response: Response,
+    responseType: 'auto' | 'json' | 'text' | 'arrayBuffer' | 'void' = 'auto'
+  ): Promise<unknown> {
+    if (responseType === 'void') {
+      return undefined;
+    }
+
+    if (response.status === 204 || response.headers.get('content-length') === '0') {
+      return undefined;
+    }
+
+    if (responseType === 'json') {
+      try {
+        return await response.json();
+      } catch {
+        return undefined;
+      }
+    }
+
+    if (responseType === 'text') {
+      const text = await response.text();
+      return text.length > 0 ? text : undefined;
+    }
+
+    if (responseType === 'arrayBuffer') {
+      const arrayBuffer = await response.arrayBuffer();
+      return arrayBuffer.byteLength > 0 ? arrayBuffer : undefined;
+    }
+
+    const contentType = response.headers.get('content-type');
+    if (contentType?.includes('application/json')) {
+      try {
+        return await response.json();
+      } catch {
+        return undefined;
+      }
+    }
+
+    const text = await response.text();
+    return text.length > 0 ? text : undefined;
+  }
+
+  private hasHeader(headers: Record<string, string>, headerName: string): boolean {
+    const target = headerName.toLowerCase();
+    return Object.keys(headers).some((key) => key.toLowerCase() === target);
+  }
+
+  private removeHeader(headers: Record<string, string>, headerName: string): void {
+    const target = headerName.toLowerCase();
+    for (const key of Object.keys(headers)) {
+      if (key.toLowerCase() === target) {
+        delete headers[key];
+      }
+    }
+  }
+
   private async buildAuthHeaders(): Promise<Record<string, string>> {
     const headers: Record<string, string> = {};
     if (this.config.getAccessToken) {
@@ -125,6 +229,8 @@ export class BaseClient {
     options?: {
       params?: Record<string, any>;
       body?: any;
+      bodyType?: 'json' | 'form-data' | 'raw';
+      responseType?: 'auto' | 'json' | 'text' | 'arrayBuffer' | 'void';
       headers?: Record<string, string>;
       signal?: AbortSignal;
     }
@@ -164,34 +270,37 @@ export class BaseClient {
     // Add auth headers
     Object.assign(headers, await this.buildAuthHeaders());
 
-    // Add content type for body requests
-    if (options?.body && !headers['Content-Type']) {
-      headers['Content-Type'] = 'application/json';
+    let requestBody: any;
+    if (options?.body !== undefined) {
+      const bodyType = options.bodyType ?? 'json';
+
+      if (bodyType === 'form-data') {
+        requestBody = options.body;
+        this.removeHeader(headers, 'Content-Type');
+      } else if (bodyType === 'raw') {
+        requestBody = options.body;
+      } else {
+        if (!this.hasHeader(headers, 'Content-Type')) {
+          headers['Content-Type'] = 'application/json';
+        }
+        requestBody = JSON.stringify(options.body);
+      }
     }
 
     const response = await fetch(url.toString(), {
       method,
       headers,
-      body: options?.body ? JSON.stringify(options.body) : undefined,
+      body: requestBody,
       signal: options?.signal,
       credentials: this.config.credentials,
     });
 
     if (!response.ok) {
-      throw new Error(\`HTTP \${response.status}: \${response.statusText}\`);
+      const errorBody = await this.parseResponseBody(response, 'auto');
+      throw new ApiError(response, errorBody);
     }
 
-    // Handle no content responses
-    if (response.status === 204 || response.headers.get('content-length') === '0') {
-      return undefined as T;
-    }
-
-    const contentType = response.headers.get('content-type');
-    if (contentType?.includes('application/json')) {
-      return response.json() as Promise<T>;
-    }
-
-    return response.text() as any;
+    return await this.parseResponseBody(response, options?.responseType ?? 'auto') as T;
   }
 
   protected async *streamEvents<T = any>(
@@ -246,7 +355,8 @@ export class BaseClient {
     });
 
     if (!response.ok) {
-      throw new Error(\`HTTP \${response.status}: \${response.statusText}\`);
+      const errorBody = await this.parseResponseBody(response);
+      throw new ApiError(response, errorBody);
     }
 
     if (!response.body) {
@@ -346,11 +456,12 @@ function generateOperation(op) {
     const lines = [];
     // Determine if this is a streaming endpoint by checking response content-type
     const isStreaming = isStreamingEndpoint(op);
+    const responseMode = inferResponseMode(op);
     // Build method signature
     // Use operationId directly as method name (already in desired format from OpenAPI)
     const methodName = op.operationId;
     const { params, isParamsOptional } = buildMethodParams(op);
-    const returnType = inferReturnType(op, isStreaming);
+    const returnType = inferReturnType(op, isStreaming, responseMode);
     // Add JSDoc comment
     if (op.summary) {
         lines.push(`  /** ${op.summary} */`);
@@ -416,6 +527,16 @@ function generateOperation(op) {
     }
     if (op.requestBody) {
         requestOptions.push(`body: ${paramsPrefix}body`);
+        const requestBodyContentType = getPreferredRequestBodyContentType(op);
+        if (requestBodyContentType === 'multipart/form-data') {
+            requestOptions.push(`bodyType: 'form-data'`);
+        }
+        else if (requestBodyContentType && requestBodyContentType !== 'application/json') {
+            requestOptions.push(`bodyType: 'raw'`);
+        }
+    }
+    if (!isStreaming && responseMode !== 'auto') {
+        requestOptions.push(`responseType: '${responseMode}'`);
     }
     if (params.includes('signal')) {
         requestOptions.push('signal: params?.signal');
@@ -457,12 +578,18 @@ function buildMethodParams(op) {
             paramFields.push(`${quotedName}${optional ? '?' : ''}: ${schemaToTypeScript(param.schema)}`);
         }
         if (op.requestBody) {
-            // Try to get the body schema from any content type (prefer application/json)
-            const bodySchema = op.requestBody.content.get('application/json') ||
-                Array.from(op.requestBody.content.values())[0];
+            const requestBodyContentType = getPreferredRequestBodyContentType(op);
+            const bodySchema = (requestBodyContentType
+                ? op.requestBody.content.get(requestBodyContentType)
+                : undefined)
+                || op.requestBody.content.get('application/json')
+                || Array.from(op.requestBody.content.values())[0];
             if (bodySchema) {
                 const optional = !op.requestBody.required;
-                paramFields.push(`body${optional ? '?' : ''}: ${schemaToTypeScript(bodySchema.schema)}`);
+                const bodyType = requestBodyContentType === 'multipart/form-data'
+                    ? 'FormData'
+                    : schemaToTypeScript(bodySchema.schema);
+                paramFields.push(`body${optional ? '?' : ''}: ${bodyType}`);
             }
         }
         paramFields.push('signal?: AbortSignal');
@@ -481,11 +608,17 @@ function buildMethodParams(op) {
     }
     return { params: params.join(', '), isParamsOptional };
 }
-function inferReturnType(op, isStreaming) {
+function inferReturnType(op, isStreaming, responseMode) {
     const successResponse = op.responses.get(200) || op.responses.get(201);
     if (!successResponse?.content) {
         return isStreaming ? 'AsyncIterable<any>' : 'Promise<void>';
     }
+    if (responseMode === 'arrayBuffer') {
+        return isStreaming ? 'AsyncIterable<any>' : 'Promise<ArrayBuffer>';
+    }
+    if (responseMode === 'text') {
+        return isStreaming ? 'AsyncIterable<any>' : 'Promise<string>';
+    }
     const jsonContent = successResponse.content.get('application/json');
     if (!jsonContent) {
         return isStreaming ? 'AsyncIterable<any>' : 'Promise<any>';
@@ -496,6 +629,46 @@ function inferReturnType(op, isStreaming) {
     }
     return `Promise<${tsType}>`;
 }
+function getPreferredRequestBodyContentType(op) {
+    if (!op.requestBody) {
+        return undefined;
+    }
+    if (op.requestBody.content.has('application/json')) {
+        return 'application/json';
+    }
+    if (op.requestBody.content.has('multipart/form-data')) {
+        return 'multipart/form-data';
+    }
+    if (op.requestBody.content.has('application/x-www-form-urlencoded')) {
+        return 'application/x-www-form-urlencoded';
+    }
+    return op.requestBody.content.keys().next().value;
+}
+function inferResponseMode(op) {
+    const successResponse = op.responses.get(200) || op.responses.get(201);
+    if (!successResponse?.content) {
+        return 'void';
+    }
+    for (const contentType of successResponse.content.keys()) {
+        const lowered = contentType.toLowerCase();
+        if (lowered.includes('application/json')) {
+            return 'auto';
+        }
+    }
+    for (const contentType of successResponse.content.keys()) {
+        const lowered = contentType.toLowerCase();
+        if (lowered.startsWith('text/')) {
+            return 'text';
+        }
+    }
+    for (const contentType of successResponse.content.keys()) {
+        const lowered = contentType.toLowerCase();
+        if (lowered.includes('zip') || lowered.includes('octet-stream')) {
+            return 'arrayBuffer';
+        }
+    }
+    return 'auto';
+}
 function generateMainClient(spec) {
     const lines = [
         `import { ClientConfig } from './base-client.js';`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taico/openapi-sdkgen",
-  "version": "0.1.2",
+  "version": "0.2.12",
   "type": "module",
   "private": false,
   "license": "MIT",