@aloma.io/integration-sdk 3.8.64 → 3.8.67

package/build/builder/runtime-context.mjs

@@ -14,10 +14,10 @@ import { Connector } from '../internal/index.mjs';
 export function buildResolvers(methods, controller) {
     const resolvers = {};
     methods.forEach((method) => {
-        const handler = async (args) => {
+        const handler = async (args, ctx) => {
             if (!methods.includes(method))
                 throw new Error(`${method} not found`);
-            return controller[method](args);
+            return controller[method](args, ctx);
         };
         if (method.includes('.')) {
             // Register nested tree for array-based resolution: ["crm", "contacts", "getPage"]

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/controller/index.d.mts

@@ -44,8 +44,9 @@ export declare abstract class AbstractController {
     /**
      * called, when the remote public method is not found on the controller
      * @param arg
+     * @param ctx optional invocation context (taskId, namespace, sticky)
      */
-    protected fallback(arg: any): Promise<any>;
+    protected fallback(arg: any, ctx?: any): Promise<any>;
     /**
      * will be invoked, when the connector has an endpoint enabled
      * will receive the data and can e.g. create a new task from it
@@ -134,7 +135,7 @@ export declare abstract class AbstractController {
     /**
      * @ignore
      **/
-    __default(arg: any): Promise<any | null>;
+    __default(arg: any, ctx?: any): Promise<any | null>;
     /**
      * @ignore
      **/

package/build/controller/index.mjs

@@ -41,8 +41,9 @@ export class AbstractController {
     /**
      * called, when the remote public method is not found on the controller
      * @param arg
+     * @param ctx optional invocation context (taskId, namespace, sticky)
      */
-    fallback(arg) {
+    fallback(arg, ctx) {
         throw new Error('method not found');
     }
     /**
@@ -136,8 +137,8 @@ export class AbstractController {
     /**
      * @ignore
      **/
-    async __default(arg) {
-        return this.fallback(arg);
+    async __default(arg, ctx) {
+        return this.fallback(arg, ctx);
     }
     /**
      * @ignore

package/build/internal/dispatcher/index.d.mts

@@ -26,10 +26,7 @@ export default class Dispatcher {
     build(): {
         introspect: () => any;
         configSchema: () => any;
-        execute: ({ query, variables }: {
-            query: any;
-            variables: any;
-        }) => Promise<any>;
+        execute: ({ query, variables, taskId, namespace, sticky }: any) => Promise<any>;
         processPacket: (packet: any) => Promise<any>;
         start: (arg: any) => Promise<void>;
     };

package/build/internal/dispatcher/index.mjs

@@ -133,7 +133,8 @@ ${arg.configurableClientScope}
             }
             return current;
         };
-        const execute = async ({ query, variables }) => {
+        const execute = async ({ query, variables, taskId, namespace, sticky }) => {
+            const ctx = { taskId, namespace, sticky };
             if (!Array.isArray(query))
                 query = [query];
             query = query
@@ -143,7 +144,7 @@ ${arg.configurableClientScope}
             const method = resolveMethod(query);
             if (!method && !_resolvers.__default)
                 throw new Error(`${originalQuery} not found`);
-            return method ? method(variables) : _resolvers.__default(variables ? { ...variables, __method: originalQuery } : variables);
+            return method ? method(variables, ctx) : _resolvers.__default(variables ? { ...variables, __method: originalQuery } : variables, ctx);
         };
         const introspect = () => local._types;
         const configSchema = () => local._config;

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.67",
   "description": "",
   "author": "aloma.io",
   "license": "Apache-2.0",
@@ -59,7 +59,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/aloma-io/integration.git",
+    "url": "git+https://github.com/aloma-io/integration.git",
     "directory": "integration-sdk"
   },
   "publishConfig": {

package/src/builder/runtime-context.mts

@@ -16,9 +16,9 @@ export function buildResolvers(methods: string[], controller: any): any {
   const resolvers: any = {};
 
   methods.forEach((method) => {
-    const handler = async (args: any) => {
+    const handler = async (args: any, ctx?: any) => {
       if (!methods.includes(method)) throw new Error(`${method} not found`);
-      return controller[method](args);
+      return controller[method](args, ctx);
     };
 
     if (method.includes('.')) {

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/controller/index.mts

@@ -51,8 +51,9 @@ export abstract class AbstractController {
   /**
    * called, when the remote public method is not found on the controller
    * @param arg
+   * @param ctx optional invocation context (taskId, namespace, sticky)
    */
-  protected fallback(arg: any): Promise<any> {
+  protected fallback(arg: any, ctx?: any): Promise<any> {
     throw new Error('method not found');
   }
 
@@ -186,8 +187,8 @@ export abstract class AbstractController {
   /**
    * @ignore
    **/
-  async __default(arg: any): Promise<any | null> {
-    return this.fallback(arg);
+  async __default(arg: any, ctx?: any): Promise<any | null> {
+    return this.fallback(arg, ctx);
   }
 
   /**

package/src/internal/dispatcher/index.mts

@@ -163,7 +163,8 @@ ${arg.configurableClientScope}
       return current;
     };
 
-    const execute = async ({query, variables}) => {
+    const execute = async ({query, variables, taskId, namespace, sticky}: any) => {
+      const ctx = {taskId, namespace, sticky};
       if (!Array.isArray(query)) query = [query];
 
       query = query
@@ -177,7 +178,7 @@ ${arg.configurableClientScope}
       const method = resolveMethod(query);
       if (!method && !_resolvers.__default) throw new Error(`${originalQuery} not found`);
 
-      return method ? method(variables) : _resolvers.__default(variables ? {...variables, __method: originalQuery} : variables);
+      return method ? method(variables, ctx) : _resolvers.__default(variables ? {...variables, __method: originalQuery} : variables, ctx);
     };
 
     const introspect = () => local._types;

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/dispatcher-ctx-forwarding.test.mjs

@@ -0,0 +1,161 @@
+import { Dispatcher } from '../build/internal/dispatcher/index.mjs';
+import { buildResolvers } from '../build/builder/runtime-context.mjs';
+
+// Simple test framework matching project convention
+const colors = {
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  reset: '\x1b[0m',
+  cyan: '\x1b[36m'
+};
+
+let passed = 0;
+let failed = 0;
+
+async function test(name, fn) {
+  try {
+    console.log(`${colors.cyan}Running: ${name}${colors.reset}`);
+    await fn();
+    console.log(`${colors.green}✓ PASS: ${name}${colors.reset}\n`);
+    passed++;
+  } catch (error) {
+    console.log(`${colors.red}✗ FAIL: ${name}${colors.reset}`);
+    console.log(`${colors.red}  Error: ${error.message}${colors.reset}\n`);
+    failed++;
+  }
+}
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message || 'Assertion failed');
+}
+
+function assertEqual(actual, expected, message) {
+  if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+    throw new Error(message || `Expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+  }
+}
+
+// Helper: build a dispatcher with given resolvers and execute a query+envelope.
+// IMPORTANT: this test passes taskId/namespace/sticky in the envelope to verify the
+// dispatcher destructures them and forwards them as a ctx object to handlers.
+async function buildAndExecute(resolvers, envelope) {
+  const dispatcher = new Dispatcher();
+  dispatcher.types({ fields: {} });
+  dispatcher.resolvers(resolvers);
+  dispatcher.main(async () => {});
+  const built = dispatcher.build();
+  return built.execute(envelope);
+}
+
+// --- RED TESTS for ctx forwarding (SDK v3.8.67 additive change) ---
+
+// Test 1: dispatcher.execute forwards ctx (taskId, namespace, sticky) to a NAMED METHOD handler
+//   as the second argument. Currently the dispatcher only passes `variables` — so the second
+//   arg is undefined and this test must FAIL (red) until the SDK is patched.
+await test('dispatcher forwards ctx as second arg to named-method handler', async () => {
+  let receivedArgs;
+  let receivedCtx;
+
+  // Use buildResolvers so the wrapper is exercised exactly as it is in production.
+  const mockController = {
+    myMethod: async (args, ctx) => {
+      receivedArgs = args;
+      receivedCtx = ctx;
+      return { ok: true };
+    },
+    '__autocomplete': async () => ({}),
+    '__endpoint': async () => ({}),
+    '__default': async () => ({}),
+  };
+  const methods = ['myMethod', '__autocomplete', '__endpoint', '__default'];
+  const resolvers = buildResolvers(methods, mockController);
+
+  await buildAndExecute(resolvers, {
+    query: ['myMethod'],
+    variables: { foo: 'bar' },
+    taskId: 'task-123',
+    namespace: 'testing',
+    sticky: 'sticky-abc',
+  });
+
+  assertEqual(receivedArgs, { foo: 'bar' }, 'args should be forwarded unchanged');
+  assert(receivedCtx !== undefined, 'ctx should be defined as second argument');
+  assertEqual(receivedCtx.taskId, 'task-123', `ctx.taskId should be "task-123", got ${JSON.stringify(receivedCtx)}`);
+  assertEqual(receivedCtx.namespace, 'testing', `ctx.namespace should be "testing", got ${JSON.stringify(receivedCtx)}`);
+  assertEqual(receivedCtx.sticky, 'sticky-abc', `ctx.sticky should be "sticky-abc", got ${JSON.stringify(receivedCtx)}`);
+});
+
+// Test 2: dispatcher.execute forwards ctx to the __default (fallback) handler as second arg
+//   when the named method is not found. Currently the __default invocation only receives the
+//   merged variables — so ctx is undefined and this test must FAIL (red) until patched.
+await test('dispatcher forwards ctx as second arg to __default fallback handler', async () => {
+  let receivedArg;
+  let receivedCtx;
+
+  // Resolvers map with ONLY __default — no named methods, so dispatcher falls back.
+  const resolvers = {
+    __default: async (arg, ctx) => {
+      receivedArg = arg;
+      receivedCtx = ctx;
+      return { fallback: true };
+    },
+  };
+
+  await buildAndExecute(resolvers, {
+    query: ['someUnknownMethod'],
+    variables: { hello: 'world' },
+    taskId: 'task-456',
+    namespace: 'testing',
+    sticky: 'sticky-def',
+  });
+
+  assert(receivedArg !== undefined, '__default should receive arg');
+  assertEqual(receivedArg.hello, 'world', 'variables should be merged into arg');
+  assertEqual(receivedArg.__method, ['someUnknownMethod'], '__method should be in arg');
+  assert(receivedCtx !== undefined, 'ctx should be defined as second argument to __default');
+  assertEqual(receivedCtx.taskId, 'task-456', `ctx.taskId should be "task-456", got ${JSON.stringify(receivedCtx)}`);
+  assertEqual(receivedCtx.namespace, 'testing', `ctx.namespace should be "testing"`);
+  assertEqual(receivedCtx.sticky, 'sticky-def', `ctx.sticky should be "sticky-def"`);
+});
+
+// Test 3: BACKWARD COMPATIBILITY. A controller method with the old 1-arg signature
+//   `async myMethod(args)` continues to work when called via the new dispatcher path.
+//   The second argument exists but is ignored. This test MUST PASS even in the red phase —
+//   if it fails red, the test setup is broken (not the implementation).
+await test('one-arg handler still works (backward compatibility)', async () => {
+  let receivedArgs;
+
+  const mockController = {
+    // Note: only one parameter. Second arg, if any, must be silently ignored.
+    legacyMethod: async (args) => {
+      receivedArgs = args;
+      return { legacy: true, ...args };
+    },
+    '__autocomplete': async () => ({}),
+    '__endpoint': async () => ({}),
+    '__default': async () => ({}),
+  };
+  const methods = ['legacyMethod', '__autocomplete', '__endpoint', '__default'];
+  const resolvers = buildResolvers(methods, mockController);
+
+  const result = await buildAndExecute(resolvers, {
+    query: ['legacyMethod'],
+    variables: { id: 7 },
+    taskId: 'task-789',
+    namespace: 'testing',
+    sticky: 'sticky-ghi',
+  });
+
+  assertEqual(receivedArgs, { id: 7 }, 'legacy handler should receive args unchanged');
+  assertEqual(result, { legacy: true, id: 7 }, 'legacy handler should return correct result');
+});
+
+// --- Results ---
+console.log(`\n${colors.yellow}--- Dispatcher ctx forwarding test results ---${colors.reset}`);
+console.log(`${colors.green}Passed: ${passed}${colors.reset}`);
+console.log(`${colors.red}Failed: ${failed}${colors.reset}`);
+
+if (failed > 0) {
+  process.exit(1);
+}

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');
 });