@onlineapps/conn-base-storage 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/conn-base-storage",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "MinIO storage connector with fingerprinting for immutable content storage",
   "main": "src/index.js",
   "scripts": {

package/src/index.js

@@ -12,8 +12,78 @@
 const Minio = require('minio');
 const crypto = require('crypto');
 const winston = require('winston');
+const dns = require('dns').promises;
 const SharedUrlAdapter = require('./sharedUrlAdapter');
 
+/**
+ * Check if string is already an IP address
+ * @param {string} str - String to check
+ * @returns {boolean} True if string is an IP address
+ */
+function isIP(str) {
+  // IPv4 pattern
+  const ipv4 = /^(\d{1,3}\.){3}\d{1,3}$/;
+  // IPv6 pattern (simplified)
+  const ipv6 = /^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/;
+  return ipv4.test(str) || ipv6.test(str);
+}
+
+/**
+ * Resolve hostname to IP address
+ * MinIO client sometimes has issues with hostnames, this ensures we use IP
+ * @param {string} host - Hostname or IP
+ * @returns {Promise<string>} Resolved IP address
+ */
+async function resolveHostToIP(host) {
+  // If already IP, return as-is
+  if (isIP(host)) {
+    return host;
+  }
+  
+  // If localhost, return as-is
+  if (host === 'localhost' || host === '127.0.0.1') {
+    return host;
+  }
+  
+  try {
+    const { address } = await dns.lookup(host);
+    return address;
+  } catch (err) {
+    // If DNS lookup fails, return original hostname
+    console.warn(`[StorageConnector] DNS lookup failed for ${host}, using original: ${err.message}`);
+    return host;
+  }
+}
+
+/**
+ * Parse storage reference to bucket and path
+ * Supports formats:
+ * - minio://bucket/path
+ * - internal://storage/bucket/path
+ * 
+ * @param {string} ref - Storage reference
+ * @returns {{ bucket: string, path: string, fingerprint?: string }}
+ */
+function parseStorageRef(ref) {
+  if (!ref || typeof ref !== 'string') {
+    throw new Error('Invalid storage reference: must be a string');
+  }
+
+  // minio://bucket/path
+  let match = ref.match(/^minio:\/\/([^/]+)\/(.+)$/);
+  if (match) {
+    return { bucket: match[1], path: match[2] };
+  }
+
+  // internal://storage/bucket/path
+  match = ref.match(/^internal:\/\/storage\/([^/]+)\/(.+)$/);
+  if (match) {
+    return { bucket: match[1], path: match[2] };
+  }
+
+  throw new Error(`Invalid storage reference format: ${ref}`);
+}
+
 /**
  * Storage connector for MinIO with automatic fingerprinting
  *
@@ -141,6 +211,30 @@ class StorageConnector {
    */
   async initialize() {
     try {
+      // Resolve hostname to IP (MinIO client can have issues with Docker hostnames)
+      const originalEndpoint = this.config.endPoint;
+      const resolvedEndpoint = await resolveHostToIP(originalEndpoint);
+      
+      if (resolvedEndpoint !== originalEndpoint) {
+        this.logger.info('StorageConnector: Resolved hostname to IP', {
+          original: originalEndpoint,
+          resolved: resolvedEndpoint
+        });
+        
+        // Recreate MinIO client with resolved IP
+        const minioConfig = {
+          endPoint: resolvedEndpoint,
+          port: this.config.port,
+          useSSL: this.config.useSSL || false,
+          accessKey: this.config.accessKey,
+          secretKey: this.config.secretKey
+        };
+        
+        this.client = new Minio.Client(minioConfig);
+        this.minioClient = this.client;
+        this.config.endPoint = resolvedEndpoint;
+      }
+      
       // Check if default bucket exists
       const bucketExists = await this.client.bucketExists(this.defaultBucket);
 
@@ -827,6 +921,49 @@ class StorageConnector {
  * @property {string} [uploadedAt] - Upload timestamp
  */
 
+/**
+ * Download file from storage reference
+ * 
+ * @param {string} ref - Storage reference (minio://bucket/path)
+ * @returns {Promise<Buffer>} File content
+ * 
+ * @example
+ * const buffer = await storage.downloadFromRef('minio://workflow/inputs/wf-123/doc.pdf');
+ */
+StorageConnector.prototype.downloadFromRef = async function(ref) {
+  const { bucket, path } = parseStorageRef(ref);
+  
+  // Download from MinIO
+  const stream = await this.client.getObject(bucket, path);
+  
+  // Collect stream data
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(chunk);
+  }
+  
+  return Buffer.concat(chunks);
+};
+
+/**
+ * Check if storage reference is valid format
+ * @param {string} ref - Reference to check
+ * @returns {boolean}
+ */
+StorageConnector.isValidRef = function(ref) {
+  try {
+    parseStorageRef(ref);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * Parse storage reference (static helper)
+ */
+StorageConnector.parseRef = parseStorageRef;
+
 // Export main class
 module.exports = StorageConnector;