@onlineapps/conn-orch-api-mapper 1.0.12 → 1.0.14

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