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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/conn-orch-api-mapper",
-  "version": "1.0.11",
+  "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

@@ -407,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;
@@ -431,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