@onlineapps/conn-orch-api-mapper 1.0.13 → 1.0.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/conn-orch-api-mapper",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "API mapping connector for OA Drive - maps cookbook operations to HTTP endpoints",
   "main": "src/index.js",
   "scripts": {

package/src/ApiMapper.js

@@ -269,6 +269,7 @@ class ApiMapper {
    */
   async _convertToDescriptor(output, schema, getContentResolver, logPrefix, context, fieldName = null) {
     const fieldLabel = fieldName ? `field '${fieldName}'` : 'output';
+    const forceFile = schema?.type === 'file';
     
     // Format 1: Base64-encoded data from HTTP response (primary format for distributed services)
     if (output && typeof output === 'object' && output.data && output.encoding === 'base64') {
@@ -368,7 +369,8 @@ class ApiMapper {
         context: {
           workflow_id: context.workflow_id || 'standalone',
           step_id: context.step_id || 'api-mapper'
-        }
+        },
+        ...(forceFile ? { forceFile: true } : {})
       });
     }
     
@@ -459,46 +461,63 @@ class ApiMapper {
       return resolver;
     };
     
-    const result = { ...input };
-    
     // Get input schema from operation (if available)
     const inputSchema = operation?.input || {};
 
-    for (const [key, value] of Object.entries(result)) {
-      // Check if this is a Content Descriptor
-      const isDescriptor = value && typeof value === 'object' && 
+    const resolveValue = async (value, schema, keyPath = '') => {
+      // If descriptor, resolve based on type
+      const isDescriptor = value && typeof value === 'object' &&
         (value._descriptor === true || value.ref || value.storage_ref);
-      
+
       if (isDescriptor) {
-        const fieldSchema = inputSchema[key] || {};
-        const fieldType = fieldSchema.type;
-        
-        // Get storage reference
-        const storageRef = value.ref || value.storage_ref;
-        
-        if (storageRef) {
-          // Resolve based on field type from operations.json
-          if (fieldType === 'file') {
-            // For file type, handler expects the Descriptor (pass through)
-            // Handler will use ContentResolver itself
-            console.log(`[ApiMapper:INPUT_RESOLVE] Field '${key}' type=file, passing Descriptor through`);
-            // Keep as-is
-          } else {
-            // For content/string types, resolve to raw string
-            console.log(`[ApiMapper:INPUT_RESOLVE] Field '${key}' type=${fieldType || 'content'}, resolving Descriptor to string`);
-            try {
-              result[key] = await getResolver().getAsString(storageRef);
-              console.log(`[ApiMapper:INPUT_RESOLVE] ✓ Resolved '${key}' from ${storageRef} (${result[key].length} chars)`);
-            } catch (err) {
-              console.error(`[ApiMapper:INPUT_RESOLVE] ✗ Failed to resolve '${key}': ${err.message}`);
-              throw new Error(`Failed to resolve Content Descriptor for '${key}': ${err.message}`);
-            }
-          }
+        const fieldType = schema?.type;
+        const storageRef = value.ref || value.storage_ref || value;
+
+        if (fieldType === 'file') {
+          // Pass-through for file type
+          return value;
+        }
+
+        try {
+          const str = await getResolver().getAsString(storageRef);
+          return str;
+        } catch (err) {
+          const label = keyPath || '<root>';
+          throw new Error(`Failed to resolve Content Descriptor for '${label}': ${err.message}`);
+        }
+      }
+
+      // Array: resolve items with item schema if available
+      if (Array.isArray(value)) {
+        const itemSchema = schema?.items || {};
+        const resolvedItems = [];
+        for (let i = 0; i < value.length; i++) {
+          resolvedItems.push(await resolveValue(value[i], itemSchema, `${keyPath}[${i}]`));
+        }
+        return resolvedItems;
+      }
+
+      // Object: recurse into properties (schema.properties if provided)
+      if (value && typeof value === 'object') {
+        const resultObj = {};
+        for (const [k, v] of Object.entries(value)) {
+          const childSchema = schema?.properties?.[k] || {};
+          resultObj[k] = await resolveValue(v, childSchema, keyPath ? `${keyPath}.${k}` : k);
         }
+        return resultObj;
       }
+
+      // Primitive or null
+      return value;
+    };
+
+    const resolved = {};
+    for (const [key, value] of Object.entries(input)) {
+      const fieldSchema = inputSchema[key] || {};
+      resolved[key] = await resolveValue(value, fieldSchema, key);
     }
 
-    return result;
+    return resolved;
   }
 
   /**
@@ -521,6 +540,8 @@ class ApiMapper {
         operations[operationId] = {
           method: (operation.method || 'POST').toUpperCase(),
           path: operation.endpoint || `/${operationId}`,
+          // Store original operations.json input schema for type-driven descriptor handling
+          input: operation.input || null,
           parameters: operation.input ? this._convertOperationsJsonInputToOpenApi(operation.input) : [],
           requestBody: operation.input ? { content: { 'application/json': { schema: { type: 'object', properties: operation.input } } } } : undefined,
           responses: operation.output ? { '200': { description: 'Success', content: { 'application/json': { schema: { type: 'object', properties: operation.output } } } } } : { '200': { description: 'Success' } },
@@ -680,12 +701,19 @@ class ApiMapper {
       }
       request.headers['Content-Type'] = 'application/json';
     } else if (operation.method === 'GET' || operation.method === 'DELETE') {
-      // For GET/DELETE, add input to query params
-      Object.entries(input).forEach(([key, value]) => {
-        if (value !== undefined && value !== null) {
-          request.params[key] = value;
-        }
-      });
+      // For GET/DELETE:
+      // - OpenAPI: rely on explicit operation.parameters (path/query/header), do NOT blindly copy all input to query
+      // - operations.json: no explicit query params → copy input as query
+      const hasExplicitNonBodyParams = Array.isArray(operation.parameters) &&
+        operation.parameters.some(p => p && p.in && p.in !== 'body');
+
+      if (!hasExplicitNonBodyParams) {
+        Object.entries(input).forEach(([key, value]) => {
+          if (value !== undefined && value !== null) {
+            request.params[key] = value;
+          }
+        });
+      }
     }
 
     return request;

package/tests/component/api-mapping-flow.test.js

@@ -511,34 +511,34 @@ describe('API Mapper Component Tests @component', () => {
   });
 
   describe('Response Transformation', () => {
-    it('should extract data from successful responses', () => {
+    it('should extract data from successful responses', async () => {
       const response = {
         data: { id: '1', name: 'John' },
         status: 200,
         headers: { 'content-type': 'application/json' }
       };
 
-      const transformed = apiMapper.transformResponse(response);
+      const transformed = await apiMapper.transformResponse(response);
       expect(transformed).toEqual({ id: '1', name: 'John' });
     });
 
-    it('should handle empty responses', () => {
+    it('should handle empty responses', async () => {
       const response = {
         data: null,
         status: 204
       };
 
-      const transformed = apiMapper.transformResponse(response);
+      const transformed = await apiMapper.transformResponse(response);
       expect(transformed).toEqual(response);
     });
 
-    it('should preserve error responses', () => {
+    it('should preserve error responses', async () => {
       const response = {
         data: { error: 'Bad request', details: 'Invalid email' },
         status: 400
       };
 
-      const transformed = apiMapper.transformResponse(response);
+      const transformed = await apiMapper.transformResponse(response);
       expect(transformed).toEqual({ error: 'Bad request', details: 'Invalid email' });
     });
   });

package/tests/unit/ApiMapper.unit.test.js

@@ -4,6 +4,15 @@ const ApiMapper = require('../../src/ApiMapper');
 const axios = require('axios');
 
 jest.mock('axios');
+jest.mock('@onlineapps/content-resolver', () => {
+  return jest.fn().mockImplementation(() => ({
+    getAsString: jest.fn(async (ref) => {
+      if (typeof ref === 'string') return `resolved:${ref}`;
+      if (ref && ref.content) return ref.content;
+      return 'resolved-descriptor';
+    })
+  }));
+});
 
 describe('ApiMapper Unit Tests @unit', () => {
   let apiMapper;
@@ -150,6 +159,75 @@ describe('ApiMapper Unit Tests @unit', () => {
     });
   });
 
+  describe('operations.json format (type-driven descriptor handling)', () => {
+    it('should store original input schema on parsed operation', () => {
+      const operationsJson = {
+        operations: {
+          'test-file-info': {
+            description: 'Test',
+            endpoint: '/api/test-file-info',
+            method: 'POST',
+            input: {
+              file: { type: 'file', required: true }
+            },
+            output: {
+              ok: { type: 'boolean' }
+            }
+          }
+        }
+      };
+
+      const mapper = new ApiMapper({
+        openApiSpec: operationsJson,
+        serviceUrl: 'http://test-service:3000',
+        logger: mockLogger
+      });
+
+      expect(mapper.operations['test-file-info']).toBeDefined();
+      expect(mapper.operations['test-file-info'].input).toEqual({
+        file: { type: 'file', required: true }
+      });
+    });
+
+    it('should pass through descriptors for input fields typed as file', async () => {
+      const operationsJson = {
+        operations: {
+          'test-file-info': {
+            description: 'Test',
+            endpoint: '/api/test-file-info',
+            method: 'POST',
+            input: {
+              file: { type: 'file', required: true }
+            },
+            output: {
+              ok: { type: 'boolean' }
+            }
+          }
+        }
+      };
+
+      apiMapper = new ApiMapper({
+        openApiSpec: operationsJson,
+        serviceUrl: 'http://test-service:3000',
+        logger: mockLogger
+      });
+
+      // Ensure we do NOT hit axios
+      axios.mockImplementation(async () => ({ status: 200, data: { ok: true } }));
+
+      const descriptor = { _descriptor: true, type: 'file', storage_ref: 'minio://bucket/path' };
+      await apiMapper.callOperation('test-file-info', { file: descriptor }, {});
+
+      expect(axios).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: 'POST',
+          url: 'http://test-service:3000/api/test-file-info',
+          data: { file: descriptor }
+        })
+      );
+    });
+  });
+
   describe('mapOperationToEndpoint', () => {
     it('should return operation details for valid operation', () => {
       const endpoint = apiMapper.mapOperationToEndpoint('getUser');
@@ -233,30 +311,30 @@ describe('ApiMapper Unit Tests @unit', () => {
   });
 
   describe('transformResponse', () => {
-    it('should extract data from response', () => {
+    it('should extract data from response', async () => {
       const response = {
         data: { id: '1', name: 'John' },
         status: 200,
         headers: {}
       };
 
-      const result = apiMapper.transformResponse(response);
+      const result = await apiMapper.transformResponse(response);
       expect(result).toEqual({ id: '1', name: 'John' });
     });
 
-    it('should handle null response', () => {
+    it('should handle null response', async () => {
       const response = {
         data: null,
         status: 204
       };
 
-      const result = apiMapper.transformResponse(response);
+      const result = await apiMapper.transformResponse(response);
       expect(result).toEqual(response);
     });
 
-    it('should pass through response without data property', () => {
+    it('should pass through response without data property', async () => {
       const response = { status: 200 };
-      const result = apiMapper.transformResponse(response);
+      const result = await apiMapper.transformResponse(response);
       expect(result).toEqual(response);
     });
   });
@@ -387,13 +465,13 @@ describe('ApiMapper Unit Tests @unit', () => {
 
       const result = await apiMapper.callOperation('getUser', { userId: '1' });
 
-      expect(axios).toHaveBeenCalledWith({
-        method: 'GET',
-        url: 'http://test-service:3000/users/1',
-        params: {},
-        headers: {},
-        data: null
-      });
+      expect(axios).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: 'GET',
+          url: 'http://test-service:3000/users/1',
+          params: {}
+        })
+      );
 
       expect(result).toEqual({ id: '1', name: 'John' });
     });
@@ -458,4 +536,64 @@ describe('ApiMapper Unit Tests @unit', () => {
       expect(result).toEqual({ id: '1' });
     });
   });
+
+  describe('_resolveContentDescriptors', () => {
+    it('should return input if not object', async () => {
+      const result = await apiMapper._resolveContentDescriptors(null);
+      expect(result).toBeNull();
+    });
+
+    it('should resolve nested descriptors based on schema types', async () => {
+      const input = {
+        doc: {
+          _descriptor: true,
+          type: 'file',
+          storage_ref: 'minio://workflow/file1'
+        },
+        meta: {
+          title: {
+            _descriptor: true,
+            type: 'inline',
+            content: 'Hello'
+          },
+          items: [
+            {
+              note: {
+                _descriptor: true,
+                type: 'inline',
+                content: 'Note 1'
+              }
+            }
+          ]
+        }
+      };
+
+      const operation = {
+        input: {
+          doc: { type: 'file' },
+          meta: {
+            type: 'object',
+            properties: {
+              title: { type: 'string' },
+              items: {
+                type: 'array',
+                items: {
+                  type: 'object',
+                  properties: {
+                    note: { type: 'string' }
+                  }
+                }
+              }
+            }
+          }
+        }
+      };
+
+      const result = await apiMapper._resolveContentDescriptors(input, operation);
+
+      expect(result.doc).toEqual(input.doc); // file passthrough
+      expect(result.meta.title).toBe('Hello');
+      expect(result.meta.items[0].note).toBe('Note 1');
+    });
+  });
 });