@aloma.io/integration-sdk 3.8.57 → 3.8.60

package/src/openapi-to-connector.mts

@@ -37,13 +37,64 @@ interface OperationInfo {
   responses?: any;
 }
 
+export interface OpenAPIToConnectorOptions {
+  nestedPaths?: boolean;
+}
+
 export class OpenAPIToConnector {
   private spec: OpenAPIV3.Document;
   private connectorName: string;
+  private options: OpenAPIToConnectorOptions;
 
-  constructor(spec: OpenAPIV3.Document, connectorName: string) {
+  constructor(spec: OpenAPIV3.Document, connectorName: string, options?: OpenAPIToConnectorOptions) {
     this.spec = spec;
     this.connectorName = connectorName;
+    this.options = options || {};
+  }
+
+  /**
+   * Derive a dotted method path from URL path and operationId.
+   * When nestedPaths is enabled, builds a namespace from the URL segments.
+   * When disabled (default), falls back to the existing flat method name.
+   */
+  deriveMethodPath(httpMethod: string, urlPath: string, operationId: string): string {
+    if (!this.options.nestedPaths) {
+      return this.generateMethodName({method: httpMethod, path: urlPath, operationId});
+    }
+
+    const VERSION_RE = /^v\d+$/;
+    const STRIP = new Set(['objects', 'items']);
+
+    // Build namespace parts from the URL path
+    const parts = urlPath
+      .replace(/\{[^}]+\}/g, '')
+      .split('/')
+      .filter(Boolean)
+      .filter((p) => !VERSION_RE.test(p))
+      .filter((p) => !STRIP.has(p));
+
+    // Extract the leaf action from operationId suffix
+    let suffix = operationId.includes('_')
+      ? operationId.split('_').pop()!
+      : httpMethod.toLowerCase();
+
+    // Bug 3 fix: If the suffix looks like a raw URL path (contains slashes),
+    // clean it by extracting meaningful segments rather than using it literally
+    if (suffix.includes('/')) {
+      const suffixParts = suffix
+        .replace(/\{[^}]+\}/g, '')
+        .split('/')
+        .filter(Boolean)
+        .filter((p) => !VERSION_RE.test(p))
+        .filter((p) => !STRIP.has(p));
+      // Use the last meaningful segment from the URL-like suffix, or fall back to HTTP method
+      suffix = suffixParts.length > 0 ? suffixParts[suffixParts.length - 1] : httpMethod.toLowerCase();
+    }
+
+    // Dedup: if suffix equals last path segment, don't repeat it
+    const last = parts[parts.length - 1];
+    if (suffix === last) return parts.join('.');
+    return [...parts, suffix].join('.');
   }
 
   /**
@@ -172,6 +223,29 @@ export class OpenAPIToConnector {
     return `${methodPrefix}_${pathSuffix}`;
   }
 
+  /**
+   * Disambiguate a colliding method name by prepending path context.
+   * E.g., "archive" from path "/contacts/batch/archive" becomes "batchArchive".
+   */
+  private disambiguateMethodName(baseName: string, operation: OperationInfo): string {
+    // Extract meaningful path segments excluding parameters and the base name itself
+    const pathParts = operation.path
+      .replace(/\{[^}]+\}/g, '')
+      .split('/')
+      .filter(Boolean)
+      .filter((p) => p.toLowerCase() !== baseName.toLowerCase());
+
+    // Use the last path segment before the method name as a distinguishing prefix
+    if (pathParts.length > 0) {
+      const prefix = pathParts[pathParts.length - 1];
+      const capitalizedBase = baseName.charAt(0).toUpperCase() + baseName.slice(1);
+      return `${prefix}${capitalizedBase}`;
+    }
+
+    // Fallback: prepend the HTTP method
+    return `${operation.method.toLowerCase()}${baseName.charAt(0).toUpperCase() + baseName.slice(1)}`;
+  }
+
   /**
    * Get the number of operations in the OpenAPI spec
    */
@@ -799,9 +873,10 @@ export class OpenAPIToConnector {
         }
         lines.push('');
       }
+
+      // Make the API call
+      lines.push(`  return this.api.fetch(url, fetchOptions);`);
     }
-    // Make the API call
-    lines.push(`    return this.api.fetch(url, fetchOptions);`);
 
     return lines.join('\n');
   }
@@ -823,7 +898,7 @@ export class OpenAPIToConnector {
 
       if (resourceSpec) {
         // Create a temporary generator for this resource's spec
-        const resourceGenerator = new OpenAPIToConnector(resourceSpec.spec, resourceName);
+        const resourceGenerator = new OpenAPIToConnector(resourceSpec.spec, resourceName, this.options);
         const operations = resourceGenerator.extractOperations();
 
         for (const operation of operations) {
@@ -832,15 +907,30 @@ export class OpenAPIToConnector {
           const signature = resourceGenerator.generateMethodSignature(operation);
 
           // Generate the exposed method that delegates to the resource
-          const exposedMethodName = `${resourceName}${methodName.charAt(0).toUpperCase() + methodName.slice(1)}`;
+          let exposedMethodName: string;
+          if (this.options.nestedPaths && operation.operationId) {
+            // Use dotted path for nested method names
+            exposedMethodName = resourceGenerator.deriveMethodPath(
+              operation.method,
+              operation.path,
+              operation.operationId
+            );
+          } else {
+            exposedMethodName = `${resourceName}${methodName.charAt(0).toUpperCase() + methodName.slice(1)}`;
+          }
 
           // Generate parameter call based on operation details
           const parameterCall = this.generateParameterCallForOperation(operation, signature);
 
+          // Use quoted method name if it contains dots
+          const methodDecl = exposedMethodName.includes('.')
+            ? `'${exposedMethodName}'`
+            : exposedMethodName;
+
           methods.push(`  /**
 ${jsdoc}
    */
-  async ${exposedMethodName}${signature} {
+  async ${methodDecl}${signature} {
     return this.${resourceName}.${methodName}(${parameterCall});
   }`);
         }
@@ -1305,9 +1395,24 @@ ${jsdoc}
 
     const resourceName = className.replace('Resource', '').toLowerCase();
 
+    // Bug 1 fix: Track used method names and disambiguate collisions
+    const usedNames = new Map<string, number>();
     const functions = operations
       .map((operation) => {
-        const methodName = this.generateMethodName(operation);
+        let methodName = this.generateMethodName(operation);
+
+        // Disambiguate duplicate names by prepending path context
+        if (usedNames.has(methodName)) {
+          methodName = this.disambiguateMethodName(methodName, operation);
+          // If still colliding after disambiguation, append a numeric suffix
+          if (usedNames.has(methodName)) {
+            const count = (usedNames.get(methodName) || 1) + 1;
+            usedNames.set(methodName, count);
+            methodName = `${methodName}${count}`;
+          }
+        }
+        usedNames.set(methodName, (usedNames.get(methodName) || 0) + 1);
+
         const jsdoc = this.generateDetailedJSDoc(operation);
         const signature = this.generateMethodSignature(operation);
         const implementation = this.generateResourceFunctionImplementation(operation);
@@ -1407,14 +1512,35 @@ ${exposedMethods}
       throw new Error('No operations found in OpenAPI specification');
     }
 
+    // Bug 1 fix: Track used method names and disambiguate collisions
+    const usedNames = new Map<string, number>();
     const methods = operations
       .map((operation) => {
-        const methodName = this.generateMethodName(operation);
+        let methodName: string;
+        if (this.options.nestedPaths && operation.operationId) {
+          methodName = this.deriveMethodPath(operation.method, operation.path, operation.operationId);
+        } else {
+          methodName = this.generateMethodName(operation);
+        }
+
+        // Disambiguate duplicate names
+        if (usedNames.has(methodName)) {
+          methodName = this.disambiguateMethodName(methodName, operation);
+          if (usedNames.has(methodName)) {
+            const count = (usedNames.get(methodName) || 1) + 1;
+            usedNames.set(methodName, count);
+            methodName = `${methodName}${count}`;
+          }
+        }
+        usedNames.set(methodName, (usedNames.get(methodName) || 0) + 1);
+
         const jsdoc = this.generateDetailedJSDoc(operation); // Use detailed JSDoc like multi-resource
         const signature = this.generateMethodSignature(operation);
         const implementation = this.generateControllerMethodImplementation(operation); // Use improved implementation
 
-        return `  /**\n${jsdoc}\n   */\n  async ${methodName}${signature} {\n${implementation}\n  }`;
+        // Use quoted method name if it contains dots
+        const methodDecl = methodName.includes('.') ? `'${methodName}'` : methodName;
+        return `  /**\n${jsdoc}\n   */\n  async ${methodDecl}${signature} {\n${implementation}\n  }`;
       })
       .join('\n\n');
 

package/test/nested-resolver.test.mjs

@@ -0,0 +1,184 @@
+import { Dispatcher } from '../build/internal/dispatcher/index.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
+async function buildAndExecute(resolvers, query, variables) {
+  const dispatcher = new Dispatcher();
+  dispatcher.types({ fields: {} });
+  dispatcher.resolvers(resolvers);
+  dispatcher.main(async () => {});
+  const built = dispatcher.build();
+  return built.execute({ query, variables });
+}
+
+// --- TESTS ---
+
+// Test 1: Dispatcher correctly resolves pre-built nested structures (baseline)
+await test('Dispatcher resolves pre-built nested structure (baseline)', async () => {
+  const handler = async (args) => ({ created: true, ...args });
+  const resolvers = { crm: { contacts: { create: handler } } };
+  const result = await buildAndExecute(resolvers, ['crm', 'contacts', 'create'], { name: 'test' });
+  assertEqual(result, { created: true, name: 'test' });
+});
+
+// Test 2: Dispatcher resolves flat keys (baseline)
+await test('Dispatcher resolves flat key (baseline)', async () => {
+  const handler = async (args) => ({ flat: true, ...args });
+  const resolvers = { contactsCreate: handler };
+  const result = await buildAndExecute(resolvers, ['contactsCreate'], { id: 1 });
+  assertEqual(result, { flat: true, id: 1 });
+});
+
+// Test 3: CRITICAL — import buildResolvers from runtime-context and verify it
+// handles dotted method names by creating nested structures.
+// This is the RED test: buildResolvers doesn't exist yet.
+await test('buildResolvers creates nested structure for dotted method names', async () => {
+  const { buildResolvers } = await import('../build/builder/runtime-context.mjs');
+
+  assert(typeof buildResolvers === 'function', 'buildResolvers should be exported from runtime-context');
+
+  const mockController = {
+    'crm.contacts.create': async (args) => ({ method: 'crm.contacts.create', ...args }),
+    'crm.contacts.list': async (args) => ({ method: 'crm.contacts.list', ...args }),
+    'flatMethod': async (args) => ({ method: 'flatMethod', ...args }),
+    '__autocomplete': async () => ({}),
+    '__endpoint': async () => ({}),
+    '__default': async () => ({}),
+  };
+
+  const methods = ['crm.contacts.create', 'crm.contacts.list', 'flatMethod', '__autocomplete', '__endpoint', '__default'];
+  const resolvers = buildResolvers(methods, mockController);
+
+  // Nested structure for dotted names
+  assert(resolvers.crm, 'resolvers.crm should exist');
+  assert(resolvers.crm.contacts, 'resolvers.crm.contacts should exist');
+  assert(typeof resolvers.crm.contacts.create === 'function', 'crm.contacts.create should be a function');
+  assert(typeof resolvers.crm.contacts.list === 'function', 'crm.contacts.list should be a function');
+
+  // Flat structure for non-dotted names
+  assert(typeof resolvers.flatMethod === 'function', 'flatMethod should be a function');
+  assert(typeof resolvers.__autocomplete === 'function', '__autocomplete should be a function');
+  assert(typeof resolvers.__endpoint === 'function', '__endpoint should be a function');
+  assert(typeof resolvers.__default === 'function', '__default should be a function');
+});
+
+// Test 4: buildResolvers nested methods resolve correctly through dispatcher
+await test('buildResolvers nested methods resolve through dispatcher end-to-end', async () => {
+  const { buildResolvers } = await import('../build/builder/runtime-context.mjs');
+
+  const mockController = {
+    'crm.contacts.create': async (args) => ({ created: true, ...(args || {}) }),
+    'crm.contacts.list': async () => ({ items: ['a', 'b'] }),
+    'flatMethod': async (args) => ({ flat: true, ...(args || {}) }),
+    '__autocomplete': async () => ({}),
+    '__endpoint': async () => ({}),
+    '__default': async () => ({}),
+  };
+
+  const methods = ['crm.contacts.create', 'crm.contacts.list', 'flatMethod', '__autocomplete', '__endpoint', '__default'];
+  const resolvers = buildResolvers(methods, mockController);
+
+  // Execute through dispatcher
+  const nestedResult = await buildAndExecute(resolvers, ['crm', 'contacts', 'create'], { name: 'Acme' });
+  assertEqual(nestedResult, { created: true, name: 'Acme' });
+
+  const listResult = await buildAndExecute(resolvers, ['crm', 'contacts', 'list'], {});
+  assertEqual(listResult, { items: ['a', 'b'] });
+
+  const flatResult = await buildAndExecute(resolvers, ['flatMethod'], { x: 42 });
+  assertEqual(flatResult, { flat: true, x: 42 });
+});
+
+// Test 5: buildResolvers preserves existing flat registration for non-dotted names
+await test('buildResolvers flat names are unchanged (backward compat)', async () => {
+  const { buildResolvers } = await import('../build/builder/runtime-context.mjs');
+
+  const mockController = {
+    'simpleMethodA': async () => ({ a: true }),
+    'simpleMethodB': async () => ({ b: true }),
+    '__autocomplete': async () => ({}),
+    '__endpoint': async () => ({}),
+    '__default': async () => ({}),
+  };
+
+  const methods = ['simpleMethodA', 'simpleMethodB', '__autocomplete', '__endpoint', '__default'];
+  const resolvers = buildResolvers(methods, mockController);
+
+  // All flat — no nested structures
+  assert(typeof resolvers.simpleMethodA === 'function', 'simpleMethodA should be a function');
+  assert(typeof resolvers.simpleMethodB === 'function', 'simpleMethodB should be a function');
+
+  const resultA = await buildAndExecute(resolvers, ['simpleMethodA'], {});
+  assertEqual(resultA, { a: true });
+
+  const resultB = await buildAndExecute(resolvers, ['simpleMethodB'], {});
+  assertEqual(resultB, { b: true });
+});
+
+// Test 6: Nested and flat coexist without overwriting each other
+await test('buildResolvers nested and flat coexist without conflicts', async () => {
+  const { buildResolvers } = await import('../build/builder/runtime-context.mjs');
+
+  const mockController = {
+    'crm.contacts.create': async () => ({ source: 'nested' }),
+    'contactsCreate': async () => ({ source: 'flat' }),
+    '__autocomplete': async () => ({}),
+    '__endpoint': async () => ({}),
+    '__default': async () => ({}),
+  };
+
+  const methods = ['crm.contacts.create', 'contactsCreate', '__autocomplete', '__endpoint', '__default'];
+  const resolvers = buildResolvers(methods, mockController);
+
+  const nestedResult = await buildAndExecute(resolvers, ['crm', 'contacts', 'create'], {});
+  assertEqual(nestedResult, { source: 'nested' });
+
+  const flatResult = await buildAndExecute(resolvers, ['contactsCreate'], {});
+  assertEqual(flatResult, { source: 'flat' });
+});
+
+// --- SUMMARY ---
+console.log(`\n${colors.yellow}📊 Nested Resolver Test Results:${colors.reset}`);
+console.log(`${colors.green}✓ Passed: ${passed}${colors.reset}`);
+console.log(`${colors.red}✗ Failed: ${failed}${colors.reset}`);
+
+if (failed > 0) {
+  console.log(`\n${colors.red}❌ Some tests failed!${colors.reset}`);
+  process.exit(1);
+} else {
+  console.log(`\n${colors.green}🎉 All nested resolver tests passed!${colors.reset}`);
+}

package/test/openapi-generator-bugs.test.mjs

@@ -0,0 +1,248 @@
+import { OpenAPIToConnector } from '../build/openapi-to-connector.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 (actual !== expected) {
+    throw new Error(message || `Expected "${expected}", got "${actual}"`);
+  }
+}
+
+// Minimal OpenAPI spec for testing
+const minimalSpec = {
+  openapi: '3.0.0',
+  info: { title: 'Test API', version: '1.0.0' },
+  paths: {}
+};
+
+// === BUG 1: Duplicate function names within a resource ===
+
+await test('Bug1: Two ops producing same method name are deduplicated in resource output', async () => {
+  // Spec with two operations that both derive "archive" as method name:
+  // POST /batch/archive -> operationId batch_archive (suffix: archive)
+  // DELETE /contacts/{id} -> operationId contacts_archive (suffix: archive)
+  const spec = {
+    openapi: '3.0.0',
+    info: { title: 'Test', version: '1.0.0' },
+    paths: {
+      '/contacts/batch/archive': {
+        post: {
+          operationId: 'batch_archive',
+          summary: 'Batch archive contacts',
+          responses: { '200': { description: 'OK' } }
+        }
+      },
+      '/contacts/{contactId}': {
+        delete: {
+          operationId: 'contacts_archive',
+          summary: 'Archive single contact',
+          parameters: [{ name: 'contactId', in: 'path', required: true, schema: { type: 'string' } }],
+          responses: { '204': { description: 'Deleted' } }
+        }
+      }
+    }
+  };
+
+  const generator = new OpenAPIToConnector(spec, 'test', { nestedPaths: false });
+  const output = generator.generateResourceClass('ContactsResource');
+
+  // Count how many times "export function archive(" appears
+  const matches = output.match(/export function archive\(/g);
+  assert(
+    !matches || matches.length <= 1,
+    `Expected at most 1 "export function archive(" but found ${matches ? matches.length : 0}. Duplicate function names!`
+  );
+
+  // There should be two distinct function declarations (disambiguated)
+  const funcDecls = output.match(/export function \w+\(/g);
+  assert(funcDecls && funcDecls.length >= 2, `Expected at least 2 distinct function declarations, got ${funcDecls ? funcDecls.length : 0}`);
+});
+
+await test('Bug1: generateController with colliding method names produces distinct methods', async () => {
+  const spec = {
+    openapi: '3.0.0',
+    info: { title: 'Test', version: '1.0.0' },
+    paths: {
+      '/items/batch/read': {
+        post: {
+          operationId: 'batch_read',
+          summary: 'Batch read items',
+          responses: { '200': { description: 'OK' } }
+        }
+      },
+      '/items/{itemId}': {
+        get: {
+          operationId: 'items_read',
+          summary: 'Read single item',
+          parameters: [{ name: 'itemId', in: 'path', required: true, schema: { type: 'string' } }],
+          responses: { '200': { description: 'OK' } }
+        }
+      }
+    }
+  };
+
+  const generator = new OpenAPIToConnector(spec, 'test', { nestedPaths: false });
+  const output = generator.generateController();
+
+  // Count occurrences of "async read(" — should be at most 1
+  const matches = output.match(/async read\(/g);
+  assert(
+    !matches || matches.length <= 1,
+    `Expected at most 1 "async read(" but found ${matches ? matches.length : 0}. Duplicate method names in controller!`
+  );
+});
+
+// === BUG 2: Dead code after return ===
+
+await test('Bug2: Resource function for simple path+params has no statements after return', async () => {
+  // A simple GET with path param and no query/body triggers the "isSimple" branch
+  // which already emits a return, but then the code unconditionally appends another return
+  const spec = {
+    openapi: '3.0.0',
+    info: { title: 'Test', version: '1.0.0' },
+    paths: {
+      '/contacts/{contactId}': {
+        get: {
+          operationId: 'getContact',
+          summary: 'Get a contact',
+          parameters: [{ name: 'contactId', in: 'path', required: true, schema: { type: 'string' } }],
+          responses: { '200': { description: 'OK' } }
+        }
+      }
+    }
+  };
+
+  const generator = new OpenAPIToConnector(spec, 'test', { nestedPaths: false });
+  const output = generator.generateResourceClass('ContactsResource');
+
+  // Extract the function body for getContact
+  const funcMatch = output.match(/export function getContact[\s\S]*?\n\}/);
+  assert(funcMatch, 'Could not find getContact function in output');
+  const funcBody = funcMatch[0];
+
+  // Find all return statements
+  const returnStatements = funcBody.match(/return this\.api\.fetch/g);
+  assert(
+    returnStatements && returnStatements.length === 1,
+    `Expected exactly 1 return statement but found ${returnStatements ? returnStatements.length : 0}. Dead code after return!`
+  );
+});
+
+await test('Bug2: Controller function for simple path+params has no dead code after return', async () => {
+  const spec = {
+    openapi: '3.0.0',
+    info: { title: 'Test', version: '1.0.0' },
+    paths: {
+      '/items/{itemId}': {
+        get: {
+          operationId: 'getItem',
+          summary: 'Get an item',
+          parameters: [{ name: 'itemId', in: 'path', required: true, schema: { type: 'string' } }],
+          responses: { '200': { description: 'OK' } }
+        }
+      }
+    }
+  };
+
+  const generator = new OpenAPIToConnector(spec, 'test', { nestedPaths: false });
+  const output = generator.generateController();
+
+  // Extract the method body for getItem
+  const methodMatch = output.match(/async getItem[\s\S]*?\n  \}/);
+  assert(methodMatch, 'Could not find getItem method in output');
+  const methodBody = methodMatch[0];
+
+  // Find all return statements
+  const returnStatements = methodBody.match(/return this\.api\.fetch/g);
+  assert(
+    returnStatements && returnStatements.length === 1,
+    `Expected exactly 1 return statement but found ${returnStatements ? returnStatements.length : 0}. Dead code after return in controller!`
+  );
+});
+
+// === BUG 3: Raw URL path segments in method names ===
+
+await test('Bug3: deriveMethodPath handles operationId with raw URL paths (lists style)', async () => {
+  const generator = new OpenAPIToConnector(minimalSpec, 'hubspot', { nestedPaths: true });
+
+  // HubSpot lists-style operationId: "get-/crm/v3/lists_/crm/v3/lists"
+  const result = generator.deriveMethodPath('GET', '/crm/v3/lists', 'get-/crm/v3/lists_/crm/v3/lists');
+
+  // Should NOT contain slashes or version numbers
+  assert(!result.includes('/'), `Method path should not contain slashes, got: "${result}"`);
+  assert(!result.includes('v3'), `Method path should not contain version numbers, got: "${result}"`);
+});
+
+await test('Bug3: deriveMethodPath handles operationId suffix that IS a raw URL path', async () => {
+  const generator = new OpenAPIToConnector(minimalSpec, 'hubspot', { nestedPaths: true });
+
+  // operationId: "post-/crm/v3/lists/search_/crm/v3/lists/search"
+  const result = generator.deriveMethodPath('POST', '/crm/v3/lists/search', 'post-/crm/v3/lists/search_/crm/v3/lists/search');
+
+  assert(!result.includes('/'), `Method path should not contain slashes, got: "${result}"`);
+  assert(!result.includes('v3'), `Method path should not contain version numbers, got: "${result}"`);
+  // Should contain "lists" and "search" in some form
+  assert(result.includes('lists'), `Method path should contain "lists", got: "${result}"`);
+  assert(result.includes('search'), `Method path should contain "search", got: "${result}"`);
+});
+
+await test('Bug3: deriveMethodPath does not produce doubled segments from URL-style operationId', async () => {
+  const generator = new OpenAPIToConnector(minimalSpec, 'hubspot', { nestedPaths: true });
+
+  // operationId: "put-/crm/v3/lists/{listId}/restore_/crm/v3/lists/{listId}/restore"
+  const result = generator.deriveMethodPath('PUT', '/crm/v3/lists/{listId}/restore', 'put-/crm/v3/lists/{listId}/restore_/crm/v3/lists/{listId}/restore');
+
+  assert(!result.includes('/'), `Method path should not contain slashes, got: "${result}"`);
+  // Should not have doubled path segments like "lists.lists" or "restore.restore"
+  const parts = result.split('.');
+  for (let i = 0; i < parts.length - 1; i++) {
+    assert(parts[i] !== parts[i + 1], `Doubled segment "${parts[i]}" in method path: "${result}"`);
+  }
+});
+
+await test('Bug3: generateMethodName (flat mode) cleans operationId with raw URL paths', async () => {
+  const generator = new OpenAPIToConnector(minimalSpec, 'hubspot', { nestedPaths: false });
+
+  // When nestedPaths is false, deriveMethodPath calls generateMethodName
+  // This should still produce a clean identifier without slashes
+  const result = generator.deriveMethodPath('GET', '/crm/v3/lists', 'get-/crm/v3/lists_/crm/v3/lists');
+
+  assert(!result.includes('/'), `Flat method name should not contain slashes, got: "${result}"`);
+  assert(/^[a-zA-Z_]/.test(result), `Method name should start with letter or underscore, got: "${result}"`);
+});
+
+// --- Report ---
+console.log(`\n${colors.yellow}===== 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);
+}