@onlineapps/conn-orch-api-mapper 1.0.6 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/conn-orch-api-mapper",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "API mapping connector for OA Drive - maps cookbook operations to HTTP endpoints",
   "main": "src/index.js",
   "scripts": {
@@ -21,7 +21,7 @@
   "license": "MIT",
   "dependencies": {
     "axios": "^1.4.0",
-    "@onlineapps/content-resolver": "^1.1.2"
+    "@onlineapps/content-resolver": "^1.1.3"
   },
   "devDependencies": {
     "jest": "^29.5.0",

package/src/ApiMapper.js

@@ -126,6 +126,11 @@ class ApiMapper {
   /**
    * Transform HTTP response to cookbook format
    * Normalizes output fields to Content Descriptor based on operations.json output schema
+   * 
+   * Supports two operations.json output formats:
+   * 1. Named fields: { "message": { "type": "string" }, "pdf": { "type": "file" } }
+   * 2. Direct type: { "type": "file", "description": "..." } (entire output is one value)
+   * 
    * @method transformResponse
    * @param {Object} httpResponse - HTTP response
    * @param {Object} [operation] - Operation schema from operations.json (for output normalization)
@@ -136,15 +141,24 @@ class ApiMapper {
     // Extract relevant data from HTTP response
     let output = httpResponse.data || httpResponse;
     
+    // === LOGGING: Input ===
+    const logPrefix = '[ApiMapper:transformResponse]';
+    console.log(`${logPrefix} INPUT:`, JSON.stringify({
+      hasOperation: !!operation,
+      operationOutput: operation?.output,
+      outputType: typeof output,
+      outputKeys: output && typeof output === 'object' ? Object.keys(output) : null,
+      output_descriptor: output?._descriptor,
+      output_type: output?.type
+    }));
+    
     // If no operation schema, return as-is
     if (!operation || !operation.output) {
+      console.log(`${logPrefix} OUTPUT: No operation schema, returning as-is`);
       return output;
     }
     
-    // Normalize output fields according to operations.json output schema
-    // Fields with type: "file" or type: "content" should be normalized to Descriptor
     const outputSchema = operation.output;
-    const normalizedOutput = { ...output };
     
     // Initialize ContentAccessor if needed (lazy initialization)
     let contentAccessor = null;
@@ -160,11 +174,115 @@ class ApiMapper {
       return contentAccessor;
     };
     
+    // === DETECT OUTPUT SCHEMA FORMAT ===
+    // Format A: Direct type - { type: "file", description: "..." }
+    // Format B: Named fields - { "fieldName": { type: "string" }, ... }
+    const isDirectType = outputSchema.type && 
+                         (outputSchema.type === 'file' || 
+                          outputSchema.type === 'content' || 
+                          outputSchema.type === 'string' ||
+                          outputSchema.type === 'object' ||
+                          outputSchema.type === 'array');
+    
+    console.log(`${logPrefix} Schema format: ${isDirectType ? 'DIRECT_TYPE' : 'NAMED_FIELDS'}`);
+    
+    // === FORMAT A: Direct type (entire output is one value) ===
+    if (isDirectType) {
+      const schemaType = outputSchema.type;
+      
+      // If schema expects file/content, ensure output is Descriptor
+      if (schemaType === 'file' || schemaType === 'content') {
+        // Check if output is already a valid Descriptor
+        if (output && typeof output === 'object' && output._descriptor === true) {
+          console.log(`${logPrefix} OUTPUT: Already Descriptor with _descriptor=true`);
+          return output;
+        }
+        
+        // Check if output looks like Descriptor but missing _descriptor flag
+        if (output && typeof output === 'object' && (output.type === 'file' || output.type === 'inline')) {
+          console.log(`${logPrefix} Normalizing Descriptor (missing _descriptor flag)`);
+          try {
+            const accessor = getContentAccessor();
+            const normalized = await accessor.normalizeToDescriptor(output, {
+              filename: output.filename,
+              content_type: output.content_type
+            });
+            console.log(`${logPrefix} OUTPUT: Normalized Descriptor:`, JSON.stringify({
+              _descriptor: normalized._descriptor,
+              type: normalized.type,
+              storage_ref: normalized.storage_ref,
+              filename: normalized.filename
+            }));
+            return normalized;
+          } catch (error) {
+            console.error(`${logPrefix} FAIL: Failed to normalize Descriptor: ${error.message}`);
+            // FAIL-FAST: Don't silently continue with broken data
+            throw new Error(`[ApiMapper] FAIL-FAST: Output is ${schemaType} but failed to normalize: ${error.message}`);
+          }
+        }
+        
+        // Output is string (storage reference) - convert to Descriptor
+        if (typeof output === 'string') {
+          console.log(`${logPrefix} Converting string to Descriptor: ${output.substring(0, 50)}...`);
+          try {
+            const accessor = getContentAccessor();
+            const normalized = await accessor.normalizeToDescriptor(output, {
+              filename: outputSchema.filename,
+              content_type: outputSchema.content_type
+            });
+            console.log(`${logPrefix} OUTPUT: String converted to Descriptor`);
+            return normalized;
+          } catch (error) {
+            console.error(`${logPrefix} FAIL: Failed to convert string to Descriptor: ${error.message}`);
+            throw new Error(`[ApiMapper] FAIL-FAST: Output is ${schemaType} but string conversion failed: ${error.message}`);
+          }
+        }
+        
+        // Output is object with storage_ref - extract and convert
+        if (output && typeof output === 'object' && output.storage_ref) {
+          console.log(`${logPrefix} Converting object with storage_ref to Descriptor`);
+          try {
+            const accessor = getContentAccessor();
+            const normalized = await accessor.normalizeToDescriptor(output.storage_ref, {
+              filename: output.filename || output.output_name,
+              content_type: output.content_type
+            });
+            console.log(`${logPrefix} OUTPUT: Object converted to Descriptor`);
+            return normalized;
+          } catch (error) {
+            console.error(`${logPrefix} FAIL: Failed to convert object to Descriptor: ${error.message}`);
+            throw new Error(`[ApiMapper] FAIL-FAST: Output is ${schemaType} but object conversion failed: ${error.message}`);
+          }
+        }
+        
+        // FAIL-FAST: Schema expects file/content but got unexpected format
+        console.error(`${logPrefix} FAIL-FAST: Schema expects ${schemaType} but got unexpected output format:`, {
+          outputType: typeof output,
+          outputKeys: output && typeof output === 'object' ? Object.keys(output) : null
+        });
+        throw new Error(`[ApiMapper] FAIL-FAST: Schema expects '${schemaType}' but received unexpected format. Output type: ${typeof output}`);
+      }
+      
+      // For other direct types (string, object, array), return as-is
+      console.log(`${logPrefix} OUTPUT: Direct type '${schemaType}', returning as-is`);
+      return output;
+    }
+    
+    // === FORMAT B: Named fields ===
+    const normalizedOutput = { ...output };
+    
     // Process each output field
     for (const [fieldName, fieldSchema] of Object.entries(outputSchema)) {
+      // Skip if fieldSchema is not an object (e.g., "type" key from Format A detected wrongly)
+      if (!fieldSchema || typeof fieldSchema !== 'object') {
+        continue;
+      }
+      
       const fieldType = fieldSchema.type;
       const fieldValue = output[fieldName];
       
+      console.log(`${logPrefix} Processing field '${fieldName}': type=${fieldType}, hasValue=${fieldValue !== undefined}`);
+      
       // Skip if field not present or null
       if (fieldValue === undefined || fieldValue === null) {
         continue;
@@ -175,42 +293,50 @@ class ApiMapper {
         try {
           const accessor = getContentAccessor();
           
-          // If field is already a Descriptor (has type property), use as-is
-          if (typeof fieldValue === 'object' && fieldValue !== null && (fieldValue.type === 'file' || fieldValue.type === 'inline')) {
-            // Already a Descriptor, normalize to ensure completeness
+          // If field is already a Descriptor (has _descriptor flag), pass through
+          if (typeof fieldValue === 'object' && fieldValue !== null && fieldValue._descriptor === true) {
+            console.log(`${logPrefix} Field '${fieldName}' already Descriptor with _descriptor=true`);
+            normalizedOutput[fieldName] = fieldValue;
+          } else if (typeof fieldValue === 'object' && fieldValue !== null && (fieldValue.type === 'file' || fieldValue.type === 'inline')) {
+            // Looks like Descriptor but missing _descriptor flag - normalize
+            console.log(`${logPrefix} Field '${fieldName}' normalizing Descriptor (missing _descriptor flag)`);
             normalizedOutput[fieldName] = await accessor.normalizeToDescriptor(fieldValue, {
               filename: fieldValue.filename,
               content_type: fieldValue.content_type
             });
           } else if (typeof fieldValue === 'string') {
             // String value - normalize to Descriptor
+            console.log(`${logPrefix} Field '${fieldName}' converting string to Descriptor`);
             normalizedOutput[fieldName] = await accessor.normalizeToDescriptor(fieldValue, {
               filename: fieldSchema.filename,
               content_type: fieldSchema.content_type
             });
-          } else if (typeof fieldValue === 'object' && fieldValue !== null) {
-            // Object value (e.g., {storage_ref: "minio://..."}) - extract and normalize
-            if (fieldValue.storage_ref) {
-              // If it's an object with storage_ref, normalize the storage_ref
-              normalizedOutput[fieldName] = await accessor.normalizeToDescriptor(fieldValue.storage_ref, {
-                filename: fieldValue.filename || fieldValue.output_name,
-                content_type: fieldValue.content_type
-              });
-            } else {
-              // Unknown object format, try to normalize as-is
-              normalizedOutput[fieldName] = await accessor.normalizeToDescriptor(fieldValue, {
-                filename: fieldSchema.filename,
-                content_type: fieldSchema.content_type
-              });
-            }
+          } else if (typeof fieldValue === 'object' && fieldValue !== null && fieldValue.storage_ref) {
+            // Object with storage_ref - extract and normalize
+            console.log(`${logPrefix} Field '${fieldName}' converting object with storage_ref to Descriptor`);
+            normalizedOutput[fieldName] = await accessor.normalizeToDescriptor(fieldValue.storage_ref, {
+              filename: fieldValue.filename || fieldValue.output_name,
+              content_type: fieldValue.content_type
+            });
+          } else {
+            // FAIL-FAST: Unexpected format for file/content field
+            console.error(`${logPrefix} FAIL-FAST: Field '${fieldName}' expects ${fieldType} but got unexpected format:`, {
+              valueType: typeof fieldValue,
+              valueKeys: fieldValue && typeof fieldValue === 'object' ? Object.keys(fieldValue) : null
+            });
+            throw new Error(`[ApiMapper] FAIL-FAST: Field '${fieldName}' expects '${fieldType}' but received unexpected format`);
           }
         } catch (error) {
-          this.logger?.warn(`Failed to normalize output field ${fieldName} to Descriptor: ${error.message}`);
-          // Keep original value on error
+          if (error.message.includes('FAIL-FAST')) {
+            throw error; // Re-throw fail-fast errors
+          }
+          console.error(`${logPrefix} FAIL: Failed to normalize field '${fieldName}': ${error.message}`);
+          throw new Error(`[ApiMapper] FAIL-FAST: Failed to normalize field '${fieldName}' to Descriptor: ${error.message}`);
         }
       }
     }
     
+    console.log(`${logPrefix} OUTPUT: Normalized fields:`, JSON.stringify(Object.keys(normalizedOutput)));
     return normalizedOutput;
   }