@aloma.io/integration-sdk 3.8.59 → 3.8.60

package/build/openapi-to-connector.d.mts

@@ -30,6 +30,11 @@ export declare class OpenAPIToConnector {
      * Generate method name from operation info
      */
     private generateMethodName;
+    /**
+     * Disambiguate a colliding method name by prepending path context.
+     * E.g., "archive" from path "/contacts/batch/archive" becomes "batchArchive".
+     */
+    private disambiguateMethodName;
     /**
      * Get the number of operations in the OpenAPI spec
      */

package/build/openapi-to-connector.mjs

@@ -48,9 +48,21 @@ export class OpenAPIToConnector {
             .filter((p) => !VERSION_RE.test(p))
             .filter((p) => !STRIP.has(p));
         // Extract the leaf action from operationId suffix
-        const suffix = operationId.includes('_')
+        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)
@@ -167,6 +179,26 @@ export class OpenAPIToConnector {
         const pathSuffix = pathParts.join('_') || 'root';
         return `${methodPrefix}_${pathSuffix}`;
     }
+    /**
+     * Disambiguate a colliding method name by prepending path context.
+     * E.g., "archive" from path "/contacts/batch/archive" becomes "batchArchive".
+     */
+    disambiguateMethodName(baseName, operation) {
+        // 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
      */
@@ -727,9 +759,9 @@ 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');
     }
     /**
@@ -1175,9 +1207,22 @@ ${jsdoc}
             throw new Error('No operations found in OpenAPI specification');
         }
         const resourceName = className.replace('Resource', '').toLowerCase();
+        // Bug 1 fix: Track used method names and disambiguate collisions
+        const usedNames = new Map();
         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);
@@ -1261,6 +1306,8 @@ ${exposedMethods}
         if (operations.length === 0) {
             throw new Error('No operations found in OpenAPI specification');
         }
+        // Bug 1 fix: Track used method names and disambiguate collisions
+        const usedNames = new Map();
         const methods = operations
             .map((operation) => {
             let methodName;
@@ -1270,6 +1317,16 @@ ${exposedMethods}
             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

package/package.json

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

package/src/openapi-to-connector.mts

@@ -74,10 +74,23 @@ export class OpenAPIToConnector {
       .filter((p) => !STRIP.has(p));
 
     // Extract the leaf action from operationId suffix
-    const suffix = operationId.includes('_')
+    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('.');
@@ -210,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
    */
@@ -837,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');
   }
@@ -1358,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);
@@ -1460,6 +1512,8 @@ ${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) => {
         let methodName: string;
@@ -1468,6 +1522,18 @@ ${exposedMethods}
         } 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

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

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

@@ -117,7 +117,7 @@ export function getOrders(this: any, options?: {status?: string, customerId?: st
     fetchOptions.params.limit = options.limit;
   }
 
-    return this.api.fetch(url, fetchOptions);
+  return this.api.fetch(url, fetchOptions);
 }
 
 /**
@@ -156,7 +156,7 @@ export function createOrder(this: any, options: {customerId: string /** Customer
     headers: options.headers,
   };
 
-    return this.api.fetch(url, fetchOptions);
+  return this.api.fetch(url, fetchOptions);
 }
 
 /**
@@ -187,7 +187,6 @@ export function getOrder(this: any, orderId: string) {
   return this.api.fetch(url, {
     method: 'GET',
   });
-    return this.api.fetch(url, fetchOptions);
 }
 
 /**
@@ -229,7 +228,7 @@ export function updateOrderStatus(this: any, orderId: string, options: {status:
     headers: options.headers,
   };
 
-    return this.api.fetch(url, fetchOptions);
+  return this.api.fetch(url, fetchOptions);
 }
 
 /**
@@ -260,5 +259,4 @@ export function cancelOrder(this: any, orderId: string) {
   return this.api.fetch(url, {
     method: 'POST',
   });
-    return this.api.fetch(url, fetchOptions);
 }

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

@@ -98,7 +98,7 @@ export function getProducts(this: any, options?: {limit?: number, category?: str
     fetchOptions.params.archived = options.archived;
   }
 
-    return this.api.fetch(url, fetchOptions);
+  return this.api.fetch(url, fetchOptions);
 }
 
 /**
@@ -138,7 +138,7 @@ export function createProduct(this: any, options: {name: string /** Product name
     headers: options.headers,
   };
 
-    return this.api.fetch(url, fetchOptions);
+  return this.api.fetch(url, fetchOptions);
 }
 
 /**
@@ -169,7 +169,6 @@ export function getProduct(this: any, productId: string) {
   return this.api.fetch(url, {
     method: 'GET',
   });
-    return this.api.fetch(url, fetchOptions);
 }
 
 /**
@@ -215,7 +214,7 @@ export function updateProduct(this: any, productId: string, options: {name: stri
     headers: options.headers,
   };
 
-    return this.api.fetch(url, fetchOptions);
+  return this.api.fetch(url, fetchOptions);
 }
 
 /**
@@ -235,5 +234,4 @@ export function deleteProduct(this: any, productId: string) {
   return this.api.fetch(url, {
     method: 'DELETE',
   });
-    return this.api.fetch(url, fetchOptions);
 }