@taico/openapi-sdkgen 0.1.1 → 0.2.12

package/dist/cli.js

@@ -7,7 +7,9 @@ if (args.length < 2) {
     process.exit(1);
 }
 const [inputPath, outputDir] = args;
-const invocationDir = process.env.INIT_CWD || process.cwd();
+const invocationDir = process.env.npm_lifecycle_event
+    ? process.cwd()
+    : (process.env.INIT_CWD || process.cwd());
 const resolvedInputPath = resolve(invocationDir, inputPath);
 const resolvedOutputDir = resolve(invocationDir, outputDir);
 generate({ inputPath: resolvedInputPath, outputDir: resolvedOutputDir })

package/dist/generator.js

@@ -32,7 +32,8 @@ function generateTypeDefinition(name, schema) {
         for (const [propName, propSchema] of schema.properties) {
             const optional = !schema.required?.includes(propName);
             const propType = schemaToTypeScript(propSchema);
-            props.push(`  ${propName}${optional ? '?' : ''}: ${propType};`);
+            const quotedPropName = quoteIfNeeded(propName);
+            props.push(`  ${quotedPropName}${optional ? '?' : ''}: ${propType};`);
         }
         return `export interface ${name} {\n${props.join('\n')}\n}`;
     }
@@ -52,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':
@@ -62,14 +63,22 @@ function schemaToTypeScript(schema) {
             baseType = 'boolean';
             break;
         case 'array':
-            baseType = schema.items ? `${schemaToTypeScript(schema.items)}[]` : 'any[]';
+            if (schema.items) {
+                const itemType = schemaToTypeScript(schema.items);
+                // Wrap in parentheses if the item type contains a union (|) to ensure correct precedence
+                baseType = itemType.includes(' | ') ? `(${itemType})[]` : `${itemType}[]`;
+            }
+            else {
+                baseType = 'any[]';
+            }
             break;
         case 'object':
             if (schema.properties) {
                 const props = [];
                 for (const [propName, propSchema] of schema.properties) {
                     const optional = !schema.required?.includes(propName);
-                    props.push(`${propName}${optional ? '?' : ''}: ${schemaToTypeScript(propSchema)}`);
+                    const quotedPropName = quoteIfNeeded(propName);
+                    props.push(`${quotedPropName}${optional ? '?' : ''}: ${schemaToTypeScript(propSchema)}`);
                 }
                 baseType = `{ ${props.join('; ')} }`;
             }
@@ -95,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) {
@@ -116,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;
     }
@@ -155,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>(
@@ -237,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) {
@@ -337,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} */`);
@@ -407,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');
@@ -448,10 +578,18 @@ function buildMethodParams(op) {
             paramFields.push(`${quotedName}${optional ? '?' : ''}: ${schemaToTypeScript(param.schema)}`);
         }
         if (op.requestBody) {
-            const bodySchema = op.requestBody.content.get('application/json');
+            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');
@@ -470,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>';
@@ -485,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/dist/parser.js

@@ -30,7 +30,7 @@ function parseOperations(paths) {
         // Parse path-level parameters (common to all operations on this path)
         const pathLevelParams = parseParameters(pathItem.parameters || []);
         for (const [method, operation] of Object.entries(pathItem)) {
-            if (!['get', 'post', 'put', 'patch', 'delete'].includes(method)) {
+            if (!['get', 'post', 'put', 'patch', 'delete', 'head', 'options'].includes(method)) {
                 continue;
             }
             const op = operation;
@@ -119,6 +119,13 @@ function parseSchema(schema) {
     if (!schema) {
         return { type: 'any' };
     }
+    if (schema.allOf?.length === 1) {
+        const merged = parseSchema(schema.allOf[0]);
+        return {
+            ...merged,
+            nullable: schema.nullable ?? merged.nullable,
+        };
+    }
     if (schema.$ref) {
         return {
             type: 'ref',

package/dist/types.d.ts

@@ -26,7 +26,7 @@ export interface Operation {
 }
 export interface Parameter {
     name: string;
-    in: 'path' | 'query' | 'header';
+    in: 'path' | 'query' | 'header' | 'cookie';
     required: boolean;
     schema: SchemaInfo;
     description?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taico/openapi-sdkgen",
-  "version": "0.1.1",
+  "version": "0.2.12",
   "type": "module",
   "private": false,
   "license": "MIT",
@@ -36,10 +36,10 @@
     "release": "npm run build && npm publish --access public"
   },
   "devDependencies": {
-    "@nestjs/common": "^11.0.0",
-    "@nestjs/core": "^11.0.0",
-    "@nestjs/platform-express": "^11.0.0",
-    "@nestjs/swagger": "^11.2.1",
+    "@nestjs/common": "^11.1.17",
+    "@nestjs/core": "^11.1.17",
+    "@nestjs/platform-express": "^11.1.17",
+    "@nestjs/swagger": "^11.2.6",
     "@types/node": "^20.0.0",
     "reflect-metadata": "^0.2.0",
     "rxjs": "^7.8.1",