@aloma.io/integration-sdk 3.8.64 → 3.8.66

package/build/cli.mjs

@@ -392,16 +392,27 @@ program
         // Create a temporary generator to generate just the exposed methods for this resource
         const tempGenerator = new OpenAPIToConnector(spec, 'temp', generatorOptions);
         const exposedMethods = tempGenerator.generateExposedResourceMethods(resources, resourceSpecs);
-        // Add the exposed methods to the controller before the closing brace
+        // Add the exposed methods to the controller, deduplicating by method name
         if (exposedMethods.trim()) {
             controllerContent = fs.readFileSync(controllerPath, 'utf-8');
-            // Find the last method and add the new exposed methods
-            const lastBrace = controllerContent.lastIndexOf('}');
-            if (lastBrace !== -1) {
-                const beforeBrace = controllerContent.substring(0, lastBrace);
-                const afterBrace = controllerContent.substring(lastBrace);
-                const updatedContent = `${beforeBrace}\n${exposedMethods}\n${afterBrace}`;
-                fs.writeFileSync(controllerPath, updatedContent);
+            // Extract existing method names from controller (async 'method.name' pattern)
+            const existingNames = new Set((controllerContent.match(/async\s+['"]([^'"]+)['"]\s*\(/g) || [])
+                .map(m => m.match(/['"]([^'"]+)['"]/)?.[1])
+                .filter(Boolean));
+            // Filter exposed methods to only include new ones
+            const methodBlocks = exposedMethods.split(/(?=\n  async ['"])/);
+            const newMethods = methodBlocks.filter(block => {
+                const nameMatch = block.match(/async\s+['"]([^'"]+)['"]\s*\(/);
+                return !nameMatch || !existingNames.has(nameMatch[1]);
+            }).join('');
+            if (newMethods.trim()) {
+                const lastBrace = controllerContent.lastIndexOf('}');
+                if (lastBrace !== -1) {
+                    const beforeBrace = controllerContent.substring(0, lastBrace);
+                    const afterBrace = controllerContent.substring(lastBrace);
+                    const updatedContent = `${beforeBrace}\n${newMethods}\n${afterBrace}`;
+                    fs.writeFileSync(controllerPath, updatedContent);
+                }
             }
         }
         console.log(`✅ Resource ${options.className} added successfully!`);

package/build/openapi-to-connector.mjs

@@ -255,6 +255,8 @@ export class OpenAPIToConnector {
             if (hasBody) {
                 this.addRequestBodyProperties(operation.requestBody, optionProps);
             }
+            // Always include headers in options type (generated code references options.headers)
+            optionProps.push('headers?: Record<string, string>');
             // Check if options parameter is required (has required query params or required body)
             const hasRequiredNonPathParams = queryParams.some((p) => p.required) || (hasBody && operation.requestBody?.required);
             const optionsRequired = hasRequiredNonPathParams ? '' : '?';
@@ -322,6 +324,8 @@ export class OpenAPIToConnector {
         if (hasBody) {
             this.addRequestBodyProperties(operation.requestBody, optionProps);
         }
+        // Always include headers in options type (generated code references options.headers)
+        optionProps.push('headers?: Record<string, string>');
         // If there are too many parameters, use simplified signature to avoid parsing issues
         // Also check if any parameter name is too long (over 100 chars) which can cause issues
         const hasLongParamNames = optionProps.some((prop) => prop.length > 100);
@@ -342,11 +346,12 @@ export class OpenAPIToConnector {
      * Resolve a schema reference to a TypeScript type name
      */
     resolveSchemaRef(ref) {
-        // Extract the component name from the reference
-        // e.g., "#/components/schemas/Company" -> "Company"
         const parts = ref.split('/');
         if (parts.length >= 2) {
             const componentName = parts[parts.length - 1];
+            if (!this.spec.components?.schemas?.[componentName]) {
+                return 'any';
+            }
             return this.sanitizeTypeName(componentName);
         }
         return 'any';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aloma.io/integration-sdk",
-  "version": "3.8.64",
+  "version": "3.8.66",
   "description": "",
   "author": "aloma.io",
   "license": "Apache-2.0",

package/src/cli.mts

@@ -485,16 +485,32 @@ program
       const tempGenerator = new OpenAPIToConnector(spec, 'temp', generatorOptions);
       const exposedMethods = tempGenerator.generateExposedResourceMethods(resources, resourceSpecs);
 
-      // Add the exposed methods to the controller before the closing brace
+      // Add the exposed methods to the controller, deduplicating by method name
       if (exposedMethods.trim()) {
         controllerContent = fs.readFileSync(controllerPath, 'utf-8');
-        // Find the last method and add the new exposed methods
-        const lastBrace = controllerContent.lastIndexOf('}');
-        if (lastBrace !== -1) {
-          const beforeBrace = controllerContent.substring(0, lastBrace);
-          const afterBrace = controllerContent.substring(lastBrace);
-          const updatedContent = `${beforeBrace}\n${exposedMethods}\n${afterBrace}`;
-          fs.writeFileSync(controllerPath, updatedContent);
+
+        // Extract existing method names from controller (async 'method.name' pattern)
+        const existingNames = new Set(
+          (controllerContent.match(/async\s+['"]([^'"]+)['"]\s*\(/g) || [])
+            .map(m => m.match(/['"]([^'"]+)['"]/)?.[1])
+            .filter(Boolean)
+        );
+
+        // Filter exposed methods to only include new ones
+        const methodBlocks = exposedMethods.split(/(?=\n  async ['"])/);
+        const newMethods = methodBlocks.filter(block => {
+          const nameMatch = block.match(/async\s+['"]([^'"]+)['"]\s*\(/);
+          return !nameMatch || !existingNames.has(nameMatch[1]);
+        }).join('');
+
+        if (newMethods.trim()) {
+          const lastBrace = controllerContent.lastIndexOf('}');
+          if (lastBrace !== -1) {
+            const beforeBrace = controllerContent.substring(0, lastBrace);
+            const afterBrace = controllerContent.substring(lastBrace);
+            const updatedContent = `${beforeBrace}\n${newMethods}\n${afterBrace}`;
+            fs.writeFileSync(controllerPath, updatedContent);
+          }
         }
       }
 

package/src/openapi-to-connector.mts

@@ -310,6 +310,9 @@ export class OpenAPIToConnector {
         this.addRequestBodyProperties(operation.requestBody, optionProps);
       }
 
+      // Always include headers in options type (generated code references options.headers)
+      optionProps.push('headers?: Record<string, string>');
+
       // Check if options parameter is required (has required query params or required body)
       const hasRequiredNonPathParams =
         queryParams.some((p) => p.required) || (hasBody && operation.requestBody?.required);
@@ -392,6 +395,9 @@ export class OpenAPIToConnector {
       this.addRequestBodyProperties(operation.requestBody, optionProps);
     }
 
+    // Always include headers in options type (generated code references options.headers)
+    optionProps.push('headers?: Record<string, string>');
+
     // If there are too many parameters, use simplified signature to avoid parsing issues
     // Also check if any parameter name is too long (over 100 chars) which can cause issues
     const hasLongParamNames = optionProps.some((prop) => prop.length > 100);
@@ -413,11 +419,12 @@ export class OpenAPIToConnector {
    * Resolve a schema reference to a TypeScript type name
    */
   private resolveSchemaRef(ref: string): string {
-    // Extract the component name from the reference
-    // e.g., "#/components/schemas/Company" -> "Company"
     const parts = ref.split('/');
     if (parts.length >= 2) {
       const componentName = parts[parts.length - 1];
+      if (!this.spec.components?.schemas?.[componentName]) {
+        return 'any';
+      }
       return this.sanitizeTypeName(componentName);
     }
     return 'any';

package/test/openapi-ts-compilation.test.mjs

@@ -0,0 +1,178 @@
+import assert from 'assert';
+import { writeFileSync, readFileSync, mkdirSync, rmSync, existsSync } from 'fs';
+import { execSync } from 'child_process';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SDK_ROOT = join(__dirname, '..');
+
+const { OpenAPIToConnector } = await import('../build/openapi-to-connector.mjs');
+
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  try { fn(); console.log(`✓ PASS: ${name}`); passed++; }
+  catch(e) { console.log(`✗ FAIL: ${name} — ${e.message}`); failed++; }
+}
+
+// --- Bug A: schema type references that are not locally defined ---
+// When a $ref points to a schema NOT present in the spec's components.schemas,
+// resolveSchemaRef still emits the type name (e.g., PublicAssociationsForObject)
+// in the function signature. Since no interface is generated, tsc fails with TS2304.
+
+test('Bug A: resolveSchemaRef emits any for types not in components.schemas', () => {
+  const spec = {
+    openapi: '3.0.0',
+    info: { title: 'Test', version: '1.0' },
+    paths: {
+      '/crm/contacts/{contactId}': {
+        put: {
+          operationId: 'updateContact',
+          parameters: [{ name: 'contactId', in: 'path', required: true, schema: { type: 'string' } }],
+          requestBody: {
+            required: true,
+            content: {
+              'application/json': {
+                schema: {
+                  type: 'object',
+                  properties: {
+                    associations: { $ref: '#/components/schemas/PublicAssociationsForObject' },
+                    properties: { type: 'object' }
+                  }
+                }
+              }
+            }
+          },
+          responses: { '200': { description: 'OK' } }
+        }
+      }
+    },
+    // Schema is referenced but NOT defined — simulates cross-file ref or incomplete spec
+    components: { schemas: {} }
+  };
+
+  const gen = new OpenAPIToConnector(spec, 'contacts', { nestedPaths: true });
+  const resourceCode = gen.generateResourceClass('ContactsResource');
+
+  // The type name must NOT appear in generated code when no interface is emitted
+  const hasTypeRef = resourceCode.includes('PublicAssociationsForObject');
+  const hasInterface = resourceCode.includes('interface PublicAssociationsForObject');
+
+  assert(!hasTypeRef || hasInterface,
+    `Type 'PublicAssociationsForObject' referenced in function signature but not defined. ` +
+    `resolveSchemaRef must emit 'any' when the schema is not in components.schemas.`);
+});
+
+// --- Bug B: add-resource produces duplicate functions on re-run ---
+// The add-resource CLI command appends exposed methods to the controller
+// without checking if they already exist. Running it twice duplicates functions.
+
+test('Bug B: add-resource CLI deduplicates exposed methods on re-run', () => {
+  const spec = {
+    openapi: '3.0.0',
+    info: { title: 'Test', version: '1.0' },
+    paths: {
+      '/crm/contacts': {
+        get: { operationId: 'getContacts', responses: { '200': { description: 'OK' } } }
+      },
+      '/crm/contacts/{id}': {
+        get: {
+          operationId: 'getContactById',
+          parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
+          responses: { '200': { description: 'OK' } }
+        }
+      }
+    }
+  };
+
+  const gen = new OpenAPIToConnector(spec, 'contacts', { nestedPaths: true });
+  const resources = [{ className: 'ContactsResource', fileName: 'contacts' }];
+  const resourceSpecs = [{ fileName: 'contacts', spec }];
+
+  const exposedMethods = gen.generateExposedResourceMethods(resources, resourceSpecs);
+
+  // Simulate a controller that already contains these methods (from first add-resource run)
+  const existingController = `export default class Controller {\n${exposedMethods}\n}`;
+
+  // Simulate the fixed CLI dedup logic: extract existing names, filter new methods
+  const existingNames = new Set(
+    (existingController.match(/async\s+['"]([^'"]+)['"]\s*\(/g) || [])
+      .map(m => m.match(/['"]([^'"]+)['"]/)?.[1])
+      .filter(Boolean)
+  );
+
+  const methodBlocks = exposedMethods.split(/(?=\n  async ['"])/);
+  const newMethods = methodBlocks.filter(block => {
+    const nameMatch = block.match(/async\s+['"]([^'"]+)['"]\s*\(/);
+    return !nameMatch || !existingNames.has(nameMatch[1]);
+  }).join('');
+
+  // After dedup, no new methods should be added (all already exist)
+  const remainingDeclarations = newMethods.match(/async\s+['"]([^'"]+)['"]\s*\(/g) || [];
+  assert(remainingDeclarations.length === 0,
+    `Dedup failed: ${remainingDeclarations.length} methods would be re-added. ` +
+    `CLI must filter out methods already present in the controller.`);
+});
+
+// --- Bug C: generated code references options.headers but type lacks headers field ---
+// The generator emits `const { headers, ...bodyData } = options;` and
+// `headers: options.headers` in fetchOptions, but the options type generated
+// for the function signature does NOT include `headers?: Record<string, string>`.
+
+test('Bug C: generated method with body includes headers in options type', () => {
+  const spec = {
+    openapi: '3.0.0',
+    info: { title: 'Test', version: '1.0' },
+    paths: {
+      '/crm/contacts': {
+        post: {
+          operationId: 'createContact',
+          requestBody: {
+            required: true,
+            content: {
+              'application/json': {
+                schema: {
+                  type: 'object',
+                  properties: {
+                    email: { type: 'string' },
+                    firstname: { type: 'string' }
+                  }
+                }
+              }
+            }
+          },
+          responses: { '201': { description: 'Created' } }
+        }
+      }
+    }
+  };
+
+  const gen = new OpenAPIToConnector(spec, 'contacts', { nestedPaths: true });
+  const resourceCode = gen.generateResourceClass('ContactsResource');
+
+  // The generator emits `const { headers, ...bodyData } = options;` and
+  // `headers: options.headers` — so the options type MUST include headers
+  const usesHeaders = resourceCode.includes('options.headers') ||
+                      resourceCode.includes('options?.headers') ||
+                      resourceCode.includes('{ headers,') ||
+                      resourceCode.includes('{ headers }');
+
+  if (usesHeaders) {
+    // Extract the function signature to check just the type definition
+    const sigMatch = resourceCode.match(/export function createContact\(this: any,([^)]+)\)/s);
+    const signature = sigMatch ? sigMatch[1] : '';
+    const hasHeadersInType = signature.includes('headers');
+    assert(hasHeadersInType,
+      `Generated code destructures/accesses 'headers' from options but the function ` +
+      `signature's options type does not include a headers field. ` +
+      `Signature: ${signature.trim()}`);
+  } else {
+    // If headers is not used, that's also a valid fix (removing the reference)
+    assert(true);
+  }
+});
+
+console.log(`\n${passed} passing / ${failed} failing`);
+if (failed > 0) process.exit(1);

package/test/scenarios/complex/expected/controller.mts

@@ -58,7 +58,7 @@ export default class Controller extends AbstractController {
  * - total?: number - Total number of products
  * - hasMore?: boolean - Whether there are more products available
    */
-  async productsGetProducts(options?: {limit?: number, category?: string, archived?: boolean}) {
+  async productsGetProducts(options?: {limit?: number, category?: string, archived?: boolean, headers?: Record<string, string>}) {
     return this.products.getProducts(options);
   }
 
@@ -85,7 +85,7 @@ export default class Controller extends AbstractController {
  * - createdAt?: string - Creation timestamp
  * - updatedAt?: string - Last update timestamp
    */
-  async productsCreateProduct(options: {name: string /** Product name */, description: string /** Product description */, price: number /** Product price */, category: string /** Product category */, tags: string[] /** Product tags */}) {
+  async productsCreateProduct(options: {name: string /** Product name */, description: string /** Product description */, price: number /** Product price */, category: string /** Product category */, tags: string[] /** Product tags */, headers?: Record<string, string>}) {
     return this.products.createProduct(options);
   }
 
@@ -108,8 +108,8 @@ export default class Controller extends AbstractController {
  * - createdAt?: string - Creation timestamp
  * - updatedAt?: string - Last update timestamp
    */
-  async productsGetProduct(productId: string) {
-    return this.products.getProduct(productId);
+  async productsGetProduct(productId: string, options?: {headers?: Record<string, string>}) {
+    return this.products.getProduct(productId, options);
   }
 
   /**
@@ -137,7 +137,7 @@ export default class Controller extends AbstractController {
  * - createdAt?: string - Creation timestamp
  * - updatedAt?: string - Last update timestamp
    */
-  async productsUpdateProduct(productId: string, options: {name: string /** Product name */, description: string /** Product description */, price: number /** Product price */, category: string /** Product category */, inStock: boolean /** Whether product is in stock */, tags: string[] /** Product tags */}) {
+  async productsUpdateProduct(productId: string, options: {name: string /** Product name */, description: string /** Product description */, price: number /** Product price */, category: string /** Product category */, inStock: boolean /** Whether product is in stock */, tags: string[] /** Product tags */, headers?: Record<string, string>}) {
     return this.products.updateProduct(productId, options);
   }
 
@@ -149,8 +149,8 @@ export default class Controller extends AbstractController {
  *
  * @returns {Promise<any>} DELETE /products/{productId} response
    */
-  async productsDeleteProduct(productId: string) {
-    return this.products.deleteProduct(productId);
+  async productsDeleteProduct(productId: string, options?: {headers?: Record<string, string>}) {
+    return this.products.deleteProduct(productId, options);
   }
 
   /**
@@ -168,7 +168,7 @@ export default class Controller extends AbstractController {
  * - total?: number - Total number of orders
  * - hasMore?: boolean - Whether there are more orders available
    */
-  async ordersGetOrders(options?: {status?: string, customerId?: string, limit?: number}) {
+  async ordersGetOrders(options?: {status?: string, customerId?: string, limit?: number, headers?: Record<string, string>}) {
     return this.orders.getOrders(options);
   }
 
@@ -194,7 +194,7 @@ export default class Controller extends AbstractController {
  * - createdAt?: string - Order creation timestamp
  * - updatedAt?: string - Last update timestamp
    */
-  async ordersCreateOrder(options: {customerId: string /** Customer who is placing the order */, items: OrderItemRequest[] /** Items to order */, shippingAddress: Address, billingAddress: Address}) {
+  async ordersCreateOrder(options: {customerId: string /** Customer who is placing the order */, items: OrderItemRequest[] /** Items to order */, shippingAddress: Address, billingAddress: Address, headers?: Record<string, string>}) {
     return this.orders.createOrder(options);
   }
 
@@ -217,8 +217,8 @@ export default class Controller extends AbstractController {
  * - createdAt?: string - Order creation timestamp
  * - updatedAt?: string - Last update timestamp
    */
-  async ordersGetOrder(orderId: string) {
-    return this.orders.getOrder(orderId);
+  async ordersGetOrder(orderId: string, options?: {headers?: Record<string, string>}) {
+    return this.orders.getOrder(orderId, options);
   }
 
   /**
@@ -242,7 +242,7 @@ export default class Controller extends AbstractController {
  * - createdAt?: string - Order creation timestamp
  * - updatedAt?: string - Last update timestamp
    */
-  async ordersUpdateOrderStatus(orderId: string, options: {status: string /** New order status */, trackingNumber: string /** Tracking number (for shipped status) */}) {
+  async ordersUpdateOrderStatus(orderId: string, options: {status: string /** New order status */, trackingNumber: string /** Tracking number (for shipped status) */, headers?: Record<string, string>}) {
     return this.orders.updateOrderStatus(orderId, options);
   }
 
@@ -265,7 +265,7 @@ export default class Controller extends AbstractController {
  * - createdAt?: string - Order creation timestamp
  * - updatedAt?: string - Last update timestamp
    */
-  async ordersCancelOrder(orderId: string) {
-    return this.orders.cancelOrder(orderId);
+  async ordersCancelOrder(orderId: string, options?: {headers?: Record<string, string>}) {
+    return this.orders.cancelOrder(orderId, options);
   }
 }

package/test/scenarios/complex/expected/orders-resource.mts

@@ -95,7 +95,7 @@ export interface UpdateOrderStatusRequest {
  * - total?: number - Total number of orders
  * - hasMore?: boolean - Whether there are more orders available
  */
-export function getOrders(this: any, options?: {status?: string, customerId?: string, limit?: number}) {
+export function getOrders(this: any, options?: {status?: string, customerId?: string, limit?: number, headers?: Record<string, string>}) {
   options = options || {};
 
   const url = '/orders';
@@ -142,7 +142,7 @@ export function getOrders(this: any, options?: {status?: string, customerId?: st
  * - createdAt?: string - Order creation timestamp
  * - updatedAt?: string - Last update timestamp
  */
-export function createOrder(this: any, options: {customerId: string /** Customer who is placing the order */, items: OrderItemRequest[] /** Items to order */, shippingAddress: Address, billingAddress: Address}) {
+export function createOrder(this: any, options: {customerId: string /** Customer who is placing the order */, items: OrderItemRequest[] /** Items to order */, shippingAddress: Address, billingAddress: Address, headers?: Record<string, string>}) {
   options = options || {};
 
   const url = '/orders';
@@ -178,7 +178,7 @@ export function createOrder(this: any, options: {customerId: string /** Customer
  * - createdAt?: string - Order creation timestamp
  * - updatedAt?: string - Last update timestamp
  */
-export function getOrder(this: any, orderId: string) {
+export function getOrder(this: any, orderId: string, options?: {headers?: Record<string, string>}) {
   let url = '/orders/{orderId}';
   if (orderId) {
     url = url.replace('{orderId}', orderId);
@@ -210,7 +210,7 @@ export function getOrder(this: any, orderId: string) {
  * - createdAt?: string - Order creation timestamp
  * - updatedAt?: string - Last update timestamp
  */
-export function updateOrderStatus(this: any, orderId: string, options: {status: string /** New order status */, trackingNumber: string /** Tracking number (for shipped status */})) {
+export function updateOrderStatus(this: any, orderId: string, options: {status: string /** New order status */, trackingNumber: string /** Tracking number (for shipped status */, headers?: Record<string, string>})) {
   options = options || {};
 
   // Build URL with path parameters
@@ -250,7 +250,7 @@ export function updateOrderStatus(this: any, orderId: string, options: {status:
  * - createdAt?: string - Order creation timestamp
  * - updatedAt?: string - Last update timestamp
  */
-export function cancelOrder(this: any, orderId: string) {
+export function cancelOrder(this: any, orderId: string, options?: {headers?: Record<string, string>}) {
   let url = '/orders/{orderId}/cancel';
   if (orderId) {
     url = url.replace('{orderId}', orderId);

package/test/scenarios/complex/expected/products-resource.mts

@@ -76,7 +76,7 @@ export interface UpdateProductRequest {
  * - total?: number - Total number of products
  * - hasMore?: boolean - Whether there are more products available
  */
-export function getProducts(this: any, options?: {limit?: number, category?: string, archived?: boolean}) {
+export function getProducts(this: any, options?: {limit?: number, category?: string, archived?: boolean, headers?: Record<string, string>}) {
   options = options || {};
 
   const url = '/products';
@@ -124,7 +124,7 @@ export function getProducts(this: any, options?: {limit?: number, category?: str
  * - createdAt?: string - Creation timestamp
  * - updatedAt?: string - Last update timestamp
  */
-export function createProduct(this: any, options: {name: string /** Product name */, description: string /** Product description */, price: number /** Product price */, category: string /** Product category */, tags: string[] /** Product tags */}) {
+export function createProduct(this: any, options: {name: string /** Product name */, description: string /** Product description */, price: number /** Product price */, category: string /** Product category */, tags: string[] /** Product tags */, headers?: Record<string, string>}) {
   options = options || {};
 
   const url = '/products';
@@ -160,7 +160,7 @@ export function createProduct(this: any, options: {name: string /** Product name
  * - createdAt?: string - Creation timestamp
  * - updatedAt?: string - Last update timestamp
  */
-export function getProduct(this: any, productId: string) {
+export function getProduct(this: any, productId: string, options?: {headers?: Record<string, string>}) {
   let url = '/products/{productId}';
   if (productId) {
     url = url.replace('{productId}', productId);
@@ -196,7 +196,7 @@ export function getProduct(this: any, productId: string) {
  * - createdAt?: string - Creation timestamp
  * - updatedAt?: string - Last update timestamp
  */
-export function updateProduct(this: any, productId: string, options: {name: string /** Product name */, description: string /** Product description */, price: number /** Product price */, category: string /** Product category */, inStock: boolean /** Whether product is in stock */, tags: string[] /** Product tags */}) {
+export function updateProduct(this: any, productId: string, options: {name: string /** Product name */, description: string /** Product description */, price: number /** Product price */, category: string /** Product category */, inStock: boolean /** Whether product is in stock */, tags: string[] /** Product tags */, headers?: Record<string, string>}) {
   options = options || {};
 
   // Build URL with path parameters
@@ -225,7 +225,7 @@ export function updateProduct(this: any, productId: string, options: {name: stri
  *
  * @returns {Promise<any>} DELETE /products/{productId} response
  */
-export function deleteProduct(this: any, productId: string) {
+export function deleteProduct(this: any, productId: string, options?: {headers?: Record<string, string>}) {
   let url = '/products/{productId}';
   if (productId) {
     url = url.replace('{productId}', productId);

package/test/scenarios/simple/expected-controller.mts

@@ -23,7 +23,7 @@ export default class Controller extends AbstractController {
  *
  * @returns {Promise<any>} GET /products response
    */
-  async getProducts() {
+  async getProducts(options?: {headers?: Record<string, string>}) {
     const url = '/products';
 
     const fetchOptions: any = {
@@ -41,7 +41,7 @@ export default class Controller extends AbstractController {
  *
  * @returns {Promise<any>} POST /products response
    */
-  async createProduct(options: {body?: any}) {
+  async createProduct(options: {body?: any, headers?: Record<string, string>}) {
     options = options || {};
 
     const url = '/products';

package/test/verify-scenarios.mjs

@@ -86,7 +86,7 @@ test('Simple Scenario - methods without options should be clean', () => {
   const generator = new OpenAPIToConnector(spec, 'simple-test');
   const actualOutput = generator.generateController();
   
-  expect(actualOutput).toInclude('async getProducts() {');
+  expect(actualOutput).toInclude('async getProducts(options?: {headers?: Record<string, string>}) {');
   expect(actualOutput).toInclude('async createProduct(options:');
 });
 
@@ -173,9 +173,9 @@ test('Path parameters and options should be handled correctly', () => {
   const generator = new OpenAPIToConnector(spec, 'test-shop');
   const actualOutput = generator.generateResourceClass('OrdersResource');
   
-  expect(actualOutput).toInclude('export function getOrder(this: any, orderId: string)');
+  expect(actualOutput).toInclude('export function getOrder(this: any, orderId: string, options?: {headers?: Record<string, string>})');
   expect(actualOutput).toInclude('export function updateOrderStatus(this: any, orderId: string, options');
-  expect(actualOutput).toInclude('export function cancelOrder(this: any, orderId: string)');
+  expect(actualOutput).toInclude('export function cancelOrder(this: any, orderId: string, options?: {headers?: Record<string, string>})');
 });
 
 // Test 8: Exposed Methods in Main Controller
@@ -279,7 +279,7 @@ test('Simple methods should not have options parameter', () => {
   const generator = new OpenAPIToConnector(simpleSpec, 'test');
   const output = generator.generateController();
   
-  expect(output).toInclude('async getSimple() {');
+  expect(output).toInclude('async getSimple(options?: {headers?: Record<string, string>}) {');
   expect(output).toNotInclude('options = options || {}');
   expect(output).toNotInclude('headers: options');
 });