@aloma.io/integration-sdk 3.8.53 → 3.8.55

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

@@ -32,6 +32,10 @@ export declare class OpenAPIToConnector {
      * Generate method signature with options object
      */
     private generateMethodSignature;
+    /**
+     * Get TypeScript type for a parameter based on its schema
+     */
+    private getParameterType;
     /**
      * Generate method implementation code
      */

package/build/openapi-to-connector.mjs

@@ -45,11 +45,21 @@ export class OpenAPIToConnector {
                 throw new Error(`Failed to parse OpenAPI spec: ${error instanceof Error ? error.message : 'Unknown error'}`);
             }
         }
-        // Validate against OpenAPI 3.x schema
+        // Validate against OpenAPI 3.x schema with lenient validation
         const validationResult = OpenAPISchema.safeParse(parsed);
         if (!validationResult.success) {
-            const errors = validationResult.error.errors.map((err) => `${err.path.join('.')}: ${err.message}`).join(', ');
-            throw new Error(`Invalid OpenAPI 3.x specification: ${errors}`);
+            // Check if the errors are just about missing 'type' fields in schemas
+            const criticalErrors = validationResult.error.errors.filter((err) => {
+                const path = err.path.join('.');
+                // Allow missing 'type' in schema definitions as many OpenAPI specs don't include it
+                return !path.includes('components.schemas') || !err.message.includes('Required');
+            });
+            if (criticalErrors.length > 0) {
+                const errors = criticalErrors.map((err) => `${err.path.join('.')}: ${err.message}`).join(', ');
+                throw new Error(`Invalid OpenAPI 3.x specification: ${errors}`);
+            }
+            // Log a warning about lenient validation
+            console.warn('⚠️  OpenAPI spec has some validation warnings but proceeding with lenient validation...');
         }
         return parsed;
     }
@@ -176,7 +186,12 @@ export class OpenAPIToConnector {
         else {
             // Options object documentation
             lines.push(' *');
-            lines.push(` * @param {Object} options (optional) - Request options`);
+            // Check if there are any required parameters
+            const hasRequiredParams = pathParams.some(p => p.required) ||
+                queryParams.some(p => p.required) ||
+                (operation.requestBody && operation.requestBody.required);
+            const optionsRequired = hasRequiredParams ? '(required)' : '(optional)';
+            lines.push(` * @param {Object} options ${optionsRequired} - Request options`);
             // Document path parameters
             for (const param of pathParams) {
                 const paramType = param.schema?.type || 'string';
@@ -218,15 +233,20 @@ export class OpenAPIToConnector {
         const pathParams = [];
         const queryParams = [];
         const hasBody = !!operation.requestBody;
-        // Identify path and query parameters
+        // Identify path and query parameters with their types and required status
         if (operation.parameters) {
             for (const param of operation.parameters) {
                 if (typeof param === 'object' && 'name' in param && 'in' in param) {
+                    const paramInfo = {
+                        name: param.name,
+                        required: param.required || false,
+                        type: this.getParameterType(param)
+                    };
                     if (param.in === 'path') {
-                        pathParams.push(param.name);
+                        pathParams.push(paramInfo);
                     }
                     else if (param.in === 'query') {
-                        queryParams.push(param.name);
+                        queryParams.push(paramInfo);
                     }
                 }
             }
@@ -234,21 +254,114 @@ export class OpenAPIToConnector {
         // If there are no query params, no body, and only path params, use simple signature
         if (queryParams.length === 0 && !hasBody && pathParams.length <= 1) {
             const params = [];
-            for (const paramName of pathParams) {
-                params.push(`${paramName}: string`);
+            for (const paramInfo of pathParams) {
+                params.push(`${paramInfo.name}: ${paramInfo.type}`);
             }
             params.push(`options?: {headers?: {[key: string]: any}}`);
             return `(${params.join(', ')})`;
         }
-        // Otherwise, use options object pattern
-        return `(options?: {${[
-            ...pathParams.map((p) => `${p}?: string`),
-            ...queryParams.map((p) => `${p}?: any`),
-            hasBody ? 'body?: any' : '',
-            'headers?: {[key: string]: any}',
-        ]
-            .filter(Boolean)
-            .join(', ')}})`;
+        // Check if there are any required parameters
+        const hasRequiredParams = pathParams.some(p => p.required) ||
+            queryParams.some(p => p.required) ||
+            (hasBody && operation.requestBody?.required);
+        // Build detailed options object with proper types
+        // Group nested properties into objects (e.g., PrimaryContact.FirstName -> PrimaryContact: {FirstName: string})
+        const nestedObjects = new Map();
+        const flatProps = [];
+        // Process all parameters (path + query)
+        const allParams = [...pathParams, ...queryParams];
+        for (const paramInfo of allParams) {
+            if (paramInfo.name.includes('.')) {
+                // This is a nested property like PrimaryContact.FirstName
+                const parts = paramInfo.name.split('.');
+                const objectName = parts[0];
+                const propertyName = parts.slice(1).join('.');
+                if (!nestedObjects.has(objectName)) {
+                    nestedObjects.set(objectName, []);
+                }
+                nestedObjects.get(objectName).push({
+                    name: propertyName,
+                    type: paramInfo.type,
+                    required: paramInfo.required
+                });
+            }
+            else {
+                // This is a flat property
+                flatProps.push({
+                    name: paramInfo.name,
+                    type: paramInfo.type,
+                    required: paramInfo.required
+                });
+            }
+        }
+        // Build the options properties array
+        const optionProps = [];
+        // Add flat properties
+        for (const prop of flatProps) {
+            const optional = prop.required ? '' : '?';
+            optionProps.push(`${prop.name}${optional}: ${prop.type}`);
+        }
+        // Add nested objects
+        for (const [objectName, properties] of nestedObjects) {
+            const nestedProps = properties.map(p => {
+                const optional = p.required ? '' : '?';
+                return `${p.name}${optional}: ${p.type}`;
+            }).join(', ');
+            // Check if all properties are optional
+            const allOptional = properties.every(p => !p.required);
+            const optional = allOptional ? '?' : '';
+            optionProps.push(`${objectName}${optional}: {${nestedProps}}`);
+        }
+        // Add request body
+        if (hasBody) {
+            optionProps.push('body?: any');
+        }
+        // Add custom headers
+        optionProps.push('headers?: {[key: string]: any}');
+        // 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);
+        if (optionProps.length > 15 || hasLongParamNames) {
+            const required = hasRequiredParams ? '' : '?';
+            return `(options${required}: {[key: string]: any})`;
+        }
+        const required = hasRequiredParams ? '' : '?';
+        return `(options${required}: {${optionProps.join(', ')}})`;
+    }
+    /**
+     * Get TypeScript type for a parameter based on its schema
+     */
+    getParameterType(param) {
+        if (param.schema) {
+            const schema = param.schema;
+            // Handle different schema types
+            if (schema.type) {
+                switch (schema.type) {
+                    case 'string':
+                        return 'string';
+                    case 'integer':
+                    case 'number':
+                        return 'number';
+                    case 'boolean':
+                        return 'boolean';
+                    case 'array':
+                        return 'any[]';
+                    case 'object':
+                        return 'any';
+                    default:
+                        return 'any';
+                }
+            }
+            // Handle enum
+            if (schema.enum) {
+                return 'string';
+            }
+            // Handle $ref
+            if (schema.$ref) {
+                return 'any';
+            }
+        }
+        return 'any';
     }
     /**
      * Generate method implementation code

package/package.json

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

package/src/openapi-to-connector.mts

@@ -65,11 +65,23 @@ export class OpenAPIToConnector {
       }
     }
 
-    // Validate against OpenAPI 3.x schema
+    // Validate against OpenAPI 3.x schema with lenient validation
     const validationResult = OpenAPISchema.safeParse(parsed);
     if (!validationResult.success) {
-      const errors = validationResult.error.errors.map((err) => `${err.path.join('.')}: ${err.message}`).join(', ');
-      throw new Error(`Invalid OpenAPI 3.x specification: ${errors}`);
+      // Check if the errors are just about missing 'type' fields in schemas
+      const criticalErrors = validationResult.error.errors.filter((err) => {
+        const path = err.path.join('.');
+        // Allow missing 'type' in schema definitions as many OpenAPI specs don't include it
+        return !path.includes('components.schemas') || !err.message.includes('Required');
+      });
+
+      if (criticalErrors.length > 0) {
+        const errors = criticalErrors.map((err) => `${err.path.join('.')}: ${err.message}`).join(', ');
+        throw new Error(`Invalid OpenAPI 3.x specification: ${errors}`);
+      }
+
+      // Log a warning about lenient validation
+      console.warn('⚠️  OpenAPI spec has some validation warnings but proceeding with lenient validation...');
     }
 
     return parsed as OpenAPIV3.Document;
@@ -213,7 +225,15 @@ export class OpenAPIToConnector {
     } else {
       // Options object documentation
       lines.push(' *');
-      lines.push(` * @param {Object} options (optional) - Request options`);
+
+      // Check if there are any required parameters
+      const hasRequiredParams =
+        pathParams.some((p) => p.required) ||
+        queryParams.some((p) => p.required) ||
+        (operation.requestBody && operation.requestBody.required);
+
+      const optionsRequired = hasRequiredParams ? '(required)' : '(optional)';
+      lines.push(` * @param {Object} options ${optionsRequired} - Request options`);
 
       // Document path parameters
       for (const param of pathParams) {
@@ -260,18 +280,24 @@ export class OpenAPIToConnector {
    * Generate method signature with options object
    */
   private generateMethodSignature(operation: OperationInfo): string {
-    const pathParams: string[] = [];
-    const queryParams: string[] = [];
+    const pathParams: Array<{name: string; required: boolean; type: string}> = [];
+    const queryParams: Array<{name: string; required: boolean; type: string}> = [];
     const hasBody = !!operation.requestBody;
 
-    // Identify path and query parameters
+    // Identify path and query parameters with their types and required status
     if (operation.parameters) {
       for (const param of operation.parameters) {
         if (typeof param === 'object' && 'name' in param && 'in' in param) {
+          const paramInfo = {
+            name: param.name,
+            required: param.required || false,
+            type: this.getParameterType(param),
+          };
+
           if (param.in === 'path') {
-            pathParams.push(param.name);
+            pathParams.push(paramInfo);
           } else if (param.in === 'query') {
-            queryParams.push(param.name);
+            queryParams.push(paramInfo);
           }
         }
       }
@@ -280,22 +306,135 @@ export class OpenAPIToConnector {
     // If there are no query params, no body, and only path params, use simple signature
     if (queryParams.length === 0 && !hasBody && pathParams.length <= 1) {
       const params: string[] = [];
-      for (const paramName of pathParams) {
-        params.push(`${paramName}: string`);
+      for (const paramInfo of pathParams) {
+        params.push(`${paramInfo.name}: ${paramInfo.type}`);
       }
       params.push(`options?: {headers?: {[key: string]: any}}`);
       return `(${params.join(', ')})`;
     }
 
-    // Otherwise, use options object pattern
-    return `(options?: {${[
-      ...pathParams.map((p) => `${p}?: string`),
-      ...queryParams.map((p) => `${p}?: any`),
-      hasBody ? 'body?: any' : '',
-      'headers?: {[key: string]: any}',
-    ]
-      .filter(Boolean)
-      .join(', ')}})`;
+    // Check if there are any required parameters
+    const hasRequiredParams =
+      pathParams.some((p) => p.required) ||
+      queryParams.some((p) => p.required) ||
+      (hasBody && operation.requestBody?.required);
+
+    // Build detailed options object with proper types
+    // Group nested properties into objects (e.g., PrimaryContact.FirstName -> PrimaryContact: {FirstName: string})
+    const nestedObjects: Map<string, Array<{name: string; type: string; required: boolean}>> = new Map();
+    const flatProps: Array<{name: string; type: string; required: boolean}> = [];
+
+    // Process all parameters (path + query)
+    const allParams = [...pathParams, ...queryParams];
+
+    for (const paramInfo of allParams) {
+      if (paramInfo.name.includes('.')) {
+        // This is a nested property like PrimaryContact.FirstName
+        const parts = paramInfo.name.split('.');
+        const objectName = parts[0];
+        const propertyName = parts.slice(1).join('.');
+
+        if (!nestedObjects.has(objectName)) {
+          nestedObjects.set(objectName, []);
+        }
+        nestedObjects.get(objectName)!.push({
+          name: propertyName,
+          type: paramInfo.type,
+          required: paramInfo.required,
+        });
+      } else {
+        // This is a flat property
+        flatProps.push({
+          name: paramInfo.name,
+          type: paramInfo.type,
+          required: paramInfo.required,
+        });
+      }
+    }
+
+    // Build the options properties array
+    const optionProps: string[] = [];
+
+    // Add flat properties
+    for (const prop of flatProps) {
+      const optional = prop.required ? '' : '?';
+      optionProps.push(`${prop.name}${optional}: ${prop.type}`);
+    }
+
+    // Add nested objects
+    for (const [objectName, properties] of nestedObjects) {
+      const nestedProps = properties
+        .map((p) => {
+          const optional = p.required ? '' : '?';
+          return `${p.name}${optional}: ${p.type}`;
+        })
+        .join(', ');
+
+      // Check if all properties are optional
+      const allOptional = properties.every((p) => !p.required);
+      const optional = allOptional ? '?' : '';
+
+      optionProps.push(`${objectName}${optional}: {${nestedProps}}`);
+    }
+
+    // Add request body
+    if (hasBody) {
+      optionProps.push('body?: any');
+    }
+
+    // Add custom headers
+    optionProps.push('headers?: {[key: string]: any}');
+
+    // 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);
+    if (optionProps.length > 15 || hasLongParamNames) {
+      const required = hasRequiredParams ? '' : '?';
+      return `(options${required}: {[key: string]: any})`;
+    }
+
+    const required = hasRequiredParams ? '' : '?';
+    return `(options${required}: {${optionProps.join(', ')}})`;
+  }
+
+  /**
+   * Get TypeScript type for a parameter based on its schema
+   */
+  private getParameterType(param: any): string {
+    if (param.schema) {
+      const schema = param.schema;
+
+      // Handle different schema types
+      if (schema.type) {
+        switch (schema.type) {
+          case 'string':
+            return 'string';
+          case 'integer':
+          case 'number':
+            return 'number';
+          case 'boolean':
+            return 'boolean';
+          case 'array':
+            return 'any[]';
+          case 'object':
+            return 'any';
+          default:
+            return 'any';
+        }
+      }
+
+      // Handle enum
+      if (schema.enum) {
+        return 'string';
+      }
+
+      // Handle $ref
+      if (schema.$ref) {
+        return 'any';
+      }
+    }
+
+    return 'any';
   }
 
   /**

package/examples/api-without-servers.json

@@ -1,32 +0,0 @@
-{
-  "openapi": "3.0.0",
-  "info": {
-    "title": "Test API",
-    "version": "1.0.0",
-    "description": "API without servers definition"
-  },
-  "paths": {
-    "/users": {
-      "get": {
-        "summary": "List users",
-        "operationId": "listUsers",
-        "parameters": [
-          {
-            "name": "limit",
-            "in": "query",
-            "schema": {
-              "type": "integer"
-            },
-            "description": "Maximum number of users"
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "Success"
-          }
-        }
-      }
-    }
-  }
-}
-