@onlineapps/content-resolver 1.1.2 → 1.1.4

package/README.md

@@ -41,6 +41,7 @@ const content = await resolver.resolve('minio://workflow/path/to/file.txt');
 // Store large content - returns Content Descriptor
 const descriptor = await resolver.store(largeText, { workflow_id: 'wf-123' }, 'document.html');
 // → {
+//     _descriptor: true,
 //     type: 'file',
 //     storage_ref: 'minio://workflow/...',
 //     filename: 'document.html',
@@ -109,6 +110,30 @@ Create Content Descriptor from raw content. Automatically decides inline vs file
 #### `normalizeToDescriptor(value, options): Promise<Object>`
 Normalize any value (string, reference, Buffer) to Content Descriptor.
 
+#### `createDescriptorFromFile(tempPath, options): Promise<Object>`
+Create Content Descriptor from a temp file. **Used by ApiMapper for file outputs.**
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `filename` | string | basename | Output filename |
+| `content_type` | string | auto-detect | MIME type |
+| `context` | Object | {} | `{ workflow_id, step_id }` |
+| `deleteAfterUpload` | boolean | true | Delete temp file after upload |
+
+```javascript
+// Handler returns temp file path
+const handlerOutput = { temp_path: '/tmp/output.pdf', filename: 'report.pdf', content_type: 'application/pdf' };
+
+// ApiMapper calls createDescriptorFromFile
+const descriptor = await resolver.createDescriptorFromFile(handlerOutput.temp_path, {
+  filename: handlerOutput.filename,
+  content_type: handlerOutput.content_type,
+  context: { workflow_id: 'wf-123', step_id: 'pdf_gen' },
+  deleteAfterUpload: true  // Cleanup temp file
+});
+// → Content Descriptor with _descriptor: true, type: 'file', storage_ref, etc.
+```
+
 #### `resolveInput(input, fields?): Promise<Object>`
 Resolves all reference fields in input object (legacy method).
 
@@ -122,6 +147,7 @@ Stores large content fields as Descriptors (returns Descriptors, not plain strin
 ```javascript
 // Inline content (small)
 {
+  _descriptor: true,
   type: 'inline',
   content: 'actual text content',
   encoding: 'utf-8',
@@ -133,6 +159,7 @@ Stores large content fields as Descriptors (returns Descriptors, not plain strin
 
 // File content (large or binary)
 {
+  _descriptor: true,
   type: 'file',
   storage_ref: 'minio://workflow/path/to/file',
   filename: 'invoice.pdf',
@@ -142,6 +169,10 @@ Stores large content fields as Descriptors (returns Descriptors, not plain strin
 }
 ```
 
+**Descriptor Identification:**
+- `_descriptor: true` - Explicit identifier that value is a Content Descriptor
+- `type: "inline"|"file"` - Distinguishes inline text from file reference
+
 ### Usage Example
 
 ```javascript

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/content-resolver",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "Automatic conversion between text content and storage references with Content Descriptor pattern",
   "main": "src/index.js",
   "scripts": {

package/src/index.js

@@ -28,7 +28,8 @@ function isDescriptor(value) {
   if (!value || typeof value !== 'object' || Array.isArray(value)) {
     return false;
   }
-  return value.type === 'inline' || value.type === 'file';
+  // Check explicit identifier first, then fallback to type check for backward compatibility
+  return value._descriptor === true || (value.type === 'inline' || value.type === 'file');
 }
 
 /**
@@ -196,6 +197,7 @@ class ContentResolver {
   async store(content, context = {}, filename = null, content_type = null) {
     if (!content) {
       return {
+        _descriptor: true,
         type: 'inline',
         content: '',
         encoding: 'utf-8',
@@ -417,6 +419,7 @@ class ContentResolver {
       const finalContentType = content_type || getContentType(finalFilename, buffer);
       
       return {
+        _descriptor: true,
         type: 'file',
         storage_ref: `minio://workflow/${result.path}`,
         filename: finalFilename,
@@ -450,6 +453,7 @@ class ContentResolver {
       const finalFilename = filename || `${result.fingerprint.slice(0, 8)}.${ext}`;
       
       return {
+        _descriptor: true,
         type: 'file',
         storage_ref: `minio://workflow/${result.path}`,
         filename: finalFilename,
@@ -464,6 +468,7 @@ class ContentResolver {
     const fingerprint = crypto.createHash('sha256').update(contentString).digest('hex');
     
     return {
+      _descriptor: true,
       type: 'inline',
       content: contentString,
       encoding: 'utf-8',
@@ -481,8 +486,12 @@ class ContentResolver {
    * @returns {Promise<Object>} Content Descriptor
    */
   async normalizeToDescriptor(value, options = {}) {
-    // Already a Descriptor
+    // Already a Descriptor - ensure it has _descriptor flag
     if (isDescriptor(value)) {
+      // Ensure _descriptor flag is present
+      if (value._descriptor !== true) {
+        return { ...value, _descriptor: true };
+      }
       return value;
     }
     
@@ -502,6 +511,110 @@ class ContentResolver {
     // Fallback
     return await this.createDescriptor(String(value), options);
   }
+
+  /**
+   * Create Content Descriptor from a temp file path
+   * Reads file, uploads to MinIO, returns Descriptor, DELETES temp file
+   * 
+   * @param {string} tempPath - Path to temp file
+   * @param {Object} options - Options
+   * @param {string} options.filename - Output filename
+   * @param {string} options.content_type - MIME type
+   * @param {Object} options.context - Workflow context { workflow_id, step_id }
+   * @param {boolean} options.deleteAfterUpload - Delete temp file after upload (default: true)
+   * @returns {Promise<Object>} Content Descriptor
+   */
+  async createDescriptorFromFile(tempPath, options = {}) {
+    const fs = require('fs');
+    const path = require('path');
+    
+    const { 
+      filename, 
+      content_type, 
+      context = {}, 
+      deleteAfterUpload = true 
+    } = options;
+    
+    // Validate temp file exists
+    if (!fs.existsSync(tempPath)) {
+      throw new Error(`[ContentResolver:FAIL] Temp file not found: ${tempPath}`);
+    }
+    
+    // Read file into buffer
+    const buffer = fs.readFileSync(tempPath);
+    const size = buffer.length;
+    
+    // Determine filename and content_type
+    const finalFilename = filename || path.basename(tempPath);
+    const finalContentType = content_type || getContentType(finalFilename, buffer);
+    
+    // Log start
+    const logContext = {
+      workflow_id: context.workflow_id || 'standalone',
+      step_id: context.step_id || 'content-resolver'
+    };
+    console.log(`[${logContext.workflow_id}:${logContext.step_id}:ContentResolver:STORE_START] ${JSON.stringify({
+      temp_path: tempPath,
+      filename: finalFilename,
+      content_type: finalContentType,
+      size: size
+    })}`);
+    
+    try {
+      // Upload to MinIO
+      const storage = await this.getStorage();
+      const workflowId = context.workflow_id || 'standalone';
+      const stepId = context.step_id || 'content';
+      const pathPrefix = `outputs/${workflowId}/${stepId}`;
+      const ext = finalFilename.split('.').pop() || 'bin';
+      
+      const result = await storage.uploadWithFingerprint(
+        'workflow',
+        buffer,
+        pathPrefix,
+        ext
+      );
+      
+      // Build Descriptor
+      const descriptor = {
+        _descriptor: true,
+        type: 'file',
+        storage_ref: `minio://workflow/${result.path}`,
+        filename: finalFilename,
+        content_type: finalContentType,
+        size: size,
+        fingerprint: result.fingerprint
+      };
+      
+      // Delete temp file if requested
+      if (deleteAfterUpload) {
+        try {
+          fs.unlinkSync(tempPath);
+        } catch (unlinkErr) {
+          console.warn(`[${logContext.workflow_id}:${logContext.step_id}:ContentResolver:WARN] Failed to delete temp file: ${unlinkErr.message}`);
+        }
+      }
+      
+      // Log success
+      console.log(`[${logContext.workflow_id}:${logContext.step_id}:ContentResolver:STORE_SUCCESS] ${JSON.stringify({
+        storage_ref: descriptor.storage_ref,
+        filename: descriptor.filename,
+        size: descriptor.size,
+        fingerprint: descriptor.fingerprint.substring(0, 16) + '...'
+      })}`);
+      
+      return descriptor;
+      
+    } catch (error) {
+      // Log failure
+      console.error(`[${logContext.workflow_id}:${logContext.step_id}:ContentResolver:STORE_FAIL] ${JSON.stringify({
+        error: error.message,
+        temp_path: tempPath,
+        filename: finalFilename
+      })}`);
+      throw error;
+    }
+  }
 }
 
 // Export class and utilities