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

package/package.json

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

package/src/ApiMapper.js

@@ -260,11 +260,50 @@ class ApiMapper {
   /**
    * Convert handler output to Descriptor
    * @private
+   * 
+   * Supported formats from handler/HTTP response:
+   * 1. { data: base64_string, encoding: 'base64', filename, content_type } - HTTP transport format
+   * 2. { temp_path, filename, content_type } - Local file (only for same-process calls)
+   * 3. Buffer - Raw binary data
+   * 4. string - Text content
    */
   async _convertToDescriptor(output, schema, getContentResolver, logPrefix, context, fieldName = null) {
     const fieldLabel = fieldName ? `field '${fieldName}'` : 'output';
     
-    // Handler should return object with temp_path for file operations
+    // Format 1: Base64-encoded data from HTTP response (primary format for distributed services)
+    if (output && typeof output === 'object' && output.data && output.encoding === 'base64') {
+      console.log(`${logPrefix}:PROCESS] ${JSON.stringify({
+        action: 'convert_base64',
+        field: fieldName,
+        filename: output.filename,
+        size: output.size
+      })}`);
+      
+      // Decode base64 to Buffer
+      const buffer = Buffer.from(output.data, 'base64');
+      
+      const resolver = getContentResolver();
+      const descriptor = await resolver.createDescriptor(buffer, {
+        filename: output.filename || schema.filename || 'output.bin',
+        content_type: output.content_type || schema.content_type,
+        context: {
+          workflow_id: context.workflow_id || 'standalone',
+          step_id: context.step_id || 'api-mapper'
+        },
+        forceFile: true  // Binary data → always store as file
+      });
+      
+      console.log(`${logPrefix}:PROCESS] ${JSON.stringify({
+        action: 'descriptor_created',
+        field: fieldName,
+        storage_ref: descriptor.storage_ref,
+        size: descriptor.size
+      })}`);
+      
+      return descriptor;
+    }
+    
+    // Format 2: Temp file path (for same-process calls, e.g. tests)
     if (output && typeof output === 'object' && output.temp_path) {
       console.log(`${logPrefix}:PROCESS] ${JSON.stringify({
         action: 'convert_temp_file',
@@ -294,7 +333,7 @@ class ApiMapper {
       return descriptor;
     }
     
-    // Handler returned Buffer - store it
+    // Format 3: Raw Buffer
     if (Buffer.isBuffer(output)) {
       console.log(`${logPrefix}:PROCESS] ${JSON.stringify({
         action: 'convert_buffer',
@@ -314,7 +353,7 @@ class ApiMapper {
       });
     }
     
-    // Handler returned string (for content type) - may be inline or stored
+    // Format 4: Plain string (text content)
     if (typeof output === 'string') {
       console.log(`${logPrefix}:PROCESS] ${JSON.stringify({
         action: 'convert_string',
@@ -338,11 +377,11 @@ class ApiMapper {
     console.error(`${logPrefix}:FAIL] ${JSON.stringify({
       error: 'UNEXPECTED_OUTPUT_FORMAT',
       field: fieldName,
-      expected: 'object with temp_path, Buffer, or string',
+      expected: '{ data, encoding: "base64" } or { temp_path } or Buffer or string',
       received: typeof output,
       receivedKeys: output && typeof output === 'object' ? Object.keys(output) : null
     })}`);
-    throw new Error(`[ApiMapper] FAIL-FAST: ${errorMsg}. Expected temp_path/Buffer/string, got ${typeof output}`);
+    throw new Error(`[ApiMapper] FAIL-FAST: ${errorMsg}. Expected base64/temp_path/Buffer/string, got ${typeof output}`);
   }
 
   /**
@@ -368,8 +407,12 @@ class ApiMapper {
       // Resolve variables in input using context
       const resolvedInput = this._resolveVariables(input, context);
 
+      // CRITICAL: Resolve Content Descriptors to raw data BEFORE calling handler
+      // Handler receives RAW DATA, not Descriptors! ApiMapper is the boundary.
+      const handlerInput = await this._resolveContentDescriptors(resolvedInput, operation);
+
       // Build request
-      const request = this._buildRequest(operation, resolvedInput);
+      const request = this._buildRequest(operation, handlerInput);
 
       // Make the call
       let response;
@@ -392,6 +435,64 @@ class ApiMapper {
     }
   }
 
+  /**
+   * Resolve Content Descriptors in input to raw data
+   * CRITICAL: Handler receives RAW DATA, not Descriptors!
+   * This is the boundary between orchestration (Descriptors) and business logic (raw data).
+   * 
+   * @private
+   * @param {Object} input - Input with potential Content Descriptors
+   * @param {Object} operation - Operation definition (for type hints)
+   * @returns {Promise<Object>} Input with Descriptors resolved to raw data
+   */
+  async _resolveContentDescriptors(input, operation) {
+    if (!input || typeof input !== 'object') {
+      return input;
+    }
+
+    const resolver = new ContentAccessor();
+    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' && 
+        (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 resolver.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}`);
+            }
+          }
+        }
+      }
+    }
+
+    return result;
+  }
+
   /**
    * Parse OpenAPI specification or operations.json to extract operations
    * @private