@onlineapps/conn-base-storage 1.0.2 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/conn-base-storage",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "MinIO storage connector with fingerprinting for immutable content storage",
   "main": "src/index.js",
   "scripts": {
@@ -20,6 +20,8 @@
     "connector"
   ],
   "dependencies": {
+    "@onlineapps/runtime-config": "1.0.2",
+    "@onlineapps/storage-core": "1.0.8",
     "minio": "^7.1.3",
     "crypto": "^1.0.1",
     "winston": "^3.8.2"

package/src/config.js

@@ -0,0 +1,53 @@
+'use strict';
+
+/**
+ * Runtime configuration schema for @onlineapps/conn-base-storage.
+ *
+ * Uses @onlineapps/runtime-config for unified priority:
+ * 1. Explicit config (passed to constructor)
+ * 2. Environment variable
+ * 3. Owner defaults (from ./defaults.js)
+ *
+ * NOTE:
+ * This module resolves MinIO runtime configuration via @onlineapps/runtime-config
+ * to avoid inline process.env access in implementation code.
+ *
+ * @module @onlineapps/conn-base-storage/config
+ */
+
+const { createRuntimeConfig } = require('@onlineapps/runtime-config');
+const DEFAULTS = require('./defaults');
+
+/**
+ * Runtime config schema for StorageConnector
+ */
+const runtimeCfg = createRuntimeConfig({
+  defaults: DEFAULTS,
+  schema: {
+    // MinIO topology (FAIL-FAST)
+    // Keep key names aligned with constructor config for predictability.
+    endPoint: { env: 'MINIO_ENDPOINT', required: true },
+    port: { env: 'MINIO_PORT', required: true, type: 'number' },
+    useSSL: { env: 'MINIO_USE_SSL', default: false, type: 'boolean' },
+    accessKey: { env: 'MINIO_ACCESS_KEY', required: true },
+    secretKey: { env: 'MINIO_SECRET_KEY', required: true },
+
+    // Wrapper behavior (module-owned defaults)
+    logLevel: { env: 'STORAGE_LOG_LEVEL', defaultKey: 'logLevel' },
+    defaultBucket: { env: 'MINIO_DEFAULT_BUCKET', defaultKey: 'defaultBucket' },
+    bucketName: { defaultKey: 'bucketName' },
+    cacheMaxSize: { defaultKey: 'cacheMaxSize', type: 'number' },
+    maxCacheSize: { defaultKey: 'maxCacheSize', type: 'number' },
+
+    // InternalUrlAdapter behavior (module-owned defaults + env hints)
+    nodeEnv: { env: 'NODE_ENV', default: 'development' },
+    dockerNetwork: { env: 'DOCKER_NETWORK', default: false, type: 'boolean' },
+    dockerEnv: { env: 'DOCKER_ENV' },
+    dockerContainer: { env: 'DOCKER_CONTAINER' },
+    hostname: { env: 'HOSTNAME' },
+    internalUrlServiceMap: { defaultKey: 'internalUrlServiceMap' },
+  }
+});
+
+module.exports = runtimeCfg;
+

package/src/defaults.js

@@ -0,0 +1,43 @@
+'use strict';
+
+/**
+ * Module-owned defaults for @onlineapps/conn-base-storage.
+ *
+ * Ownership rule:
+ * - Defaults for the StorageConnector wrapper live here (bucket naming, cache sizing, log level).
+ * - MinIO connection defaults belong to @onlineapps/storage-core.
+ */
+
+module.exports = {
+  logLevel: 'info',
+  defaultBucket: 'api-storage',
+  bucketName: 'oa-drive-storage',
+  cacheMaxSize: 100,
+  maxCacheSize: 100,
+
+  // InternalUrlAdapter defaults (module-owned)
+  internalUrlServiceMap: {
+    storage: {
+      docker: 'api_services_storage:9000',
+      local: 'localhost:9000'
+    },
+    registry: {
+      docker: 'api_registry:8080',
+      local: 'localhost:8080'
+    },
+    monitoring: {
+      docker: 'api_monitoring:3000',
+      local: 'localhost:3000'
+    },
+    mq: {
+      docker: 'api_services_rabbit:5672',
+      local: 'localhost:5672'
+    },
+    cache: {
+      docker: 'api_node_cache:6379',
+      local: 'localhost:6379'
+    }
+  },
+};
+
+

package/src/index.js

@@ -9,80 +9,10 @@
  * @since 1.0.0
  */
 
-const Minio = require('minio');
-const crypto = require('crypto');
+const { StorageCore } = require('@onlineapps/storage-core');
 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}`);
-}
+const runtimeCfg = require('./config');
 
 /**
  * Storage connector for MinIO with automatic fingerprinting
@@ -139,9 +69,12 @@ class StorageConnector {
    * });
    */
   constructor(config = {}) {
+    // Resolve runtime configuration for wrapper behavior
+    const resolved = runtimeCfg.resolve(config);
+
     // Logger setup
     this.logger = winston.createLogger({
-      level: config.logLevel || 'info',
+      level: resolved.logLevel,
       format: winston.format.combine(
         winston.format.timestamp(),
         winston.format.json()
@@ -151,33 +84,37 @@ class StorageConnector {
       ]
     });
 
-    // MinIO client configuration
-    const minioConfig = {
-      endPoint: config.endPoint || process.env.MINIO_ENDPOINT || 'localhost',
-      port: parseInt(config.port || process.env.MINIO_PORT || 9000),
-      useSSL: config.useSSL || process.env.MINIO_USE_SSL === 'true',
-      accessKey: config.accessKey || process.env.MINIO_ACCESS_KEY || 'minioadmin',
-      secretKey: config.secretKey || process.env.MINIO_SECRET_KEY || 'minioadmin'
-    };
+    // Create StorageCore instance (handles MinIO client internally)
+    this.core = new StorageCore({
+      endPoint: resolved.endPoint,
+      port: resolved.port,
+      useSSL: resolved.useSSL,
+      accessKey: resolved.accessKey,
+      secretKey: resolved.secretKey
+    });
+
+    // Expose MinIO client for backward compatibility
+    this.client = this.core.client;
+    this.minioClient = this.core.client;
 
-    this.client = new Minio.Client(minioConfig);
-    this.defaultBucket = config.defaultBucket || process.env.MINIO_DEFAULT_BUCKET || 'api-storage';
+    this.defaultBucket = resolved.defaultBucket;
 
     // Store config for access in tests
     this.config = {
-      ...minioConfig,
-      bucketName: this.validateBucketName(config.bucketName || 'oa-drive-storage'),
-      cacheMaxSize: config.cacheMaxSize || 100
+      endPoint: this.core.config.endPoint,
+      port: this.core.config.port,
+      useSSL: this.core.config.useSSL,
+      accessKey: this.core.config.accessKey,
+      secretKey: this.core.config.secretKey,
+      bucketName: this.validateBucketName(config.bucketName || resolved.bucketName),
+      cacheMaxSize: resolved.cacheMaxSize
     };
 
-    // MinIO client
-    this.minioClient = this.client;
-
     // Cache configuration
     this.cacheEnabled = config.cacheEnabled !== false;
     this.cache = new Map();
     this.contentCache = new Map();
-    this.maxCacheSize = config.maxCacheSize || 100; // Max items in cache
+    this.maxCacheSize = resolved.maxCacheSize;
 
     // Track initialization
     this.initialized = false;
@@ -186,8 +123,8 @@ class StorageConnector {
     this.sharedUrl = new SharedUrlAdapter(this);
 
     this.logger.info('StorageConnector initialized', {
-      endpoint: minioConfig.endPoint,
-      port: minioConfig.port,
+      endpoint: this.core.config.endPoint,
+      port: this.core.config.port,
       defaultBucket: this.defaultBucket
     });
   }
@@ -211,39 +148,16 @@ 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);
+      // Initialize StorageCore
+      await this.core.initialize();
+
+      // Ensure default bucket exists (using StorageCore)
+      const created = await this.core.ensureBucket(this.defaultBucket);
 
-      if (!bucketExists) {
-        // Create bucket with versioning
-        await this.client.makeBucket(this.defaultBucket, 'us-east-1');
+      if (created) {
         this.logger.info(`Bucket ${this.defaultBucket} created`);
 
-        // Set bucket policy for read access
+        // Set bucket policy for read access (business-specific feature)
         const policy = {
           Version: '2012-10-17',
           Statement: [
@@ -287,25 +201,8 @@ class StorageConnector {
    * // Returns consistent hash for the object
    */
   generateFingerprint(content) {
-    // Handle undefined and null
-    if (content === undefined || content === null) {
-      content = String(content);
-    } else if (typeof content === 'symbol') {
-      content = content.toString();
-    } else if (typeof content !== 'string' && !Buffer.isBuffer(content)) {
-      // Handle circular references
-      try {
-        content = JSON.stringify(content);
-      } catch (err) {
-        // If circular reference, use a deterministic string representation
-        content = '[Circular Reference]';
-      }
-    }
-
-    return crypto
-      .createHash('sha256')
-      .update(content)
-      .digest('hex');
+    // Delegate to StorageCore
+    return this.core.calculateFingerprint(content);
   }
 
   /**
@@ -371,9 +268,9 @@ class StorageConnector {
         ? `${pathPrefix}/${fingerprint}.json`
         : `${fingerprint}.json`;
 
-      // Check if object already exists (immutable)
-      try {
-        await this.client.statObject(bucket, path);
+      // Check if object already exists (immutable) - using StorageCore
+      const exists = await this.core.objectExists(bucket, path);
+      if (exists) {
         this.logger.debug(`Object already exists: ${bucket}/${path}`);
 
         return {
@@ -383,16 +280,13 @@ class StorageConnector {
           url: this.getPublicUrl(bucket, path),
           existed: true
         };
-      } catch (err) {
-        // Object doesn't exist, proceed with upload
       }
 
-      // Upload to MinIO
-      await this.client.putObject(
+      // Upload to MinIO - using StorageCore
+      await this.core.putObject(
         bucket,
         path,
         buffer,
-        buffer.length,
         {
           'Content-Type': 'application/json',
           'x-amz-meta-fingerprint': fingerprint,
@@ -460,8 +354,8 @@ class StorageConnector {
         return this.contentCache.get(cacheKey);
       }
 
-      // Download from MinIO
-      const stream = await this.client.getObject(bucket, path);
+      // Download from MinIO - using StorageCore
+      const stream = await this.core.getObject(bucket, path);
 
       // Collect stream data
       const chunks = [];
@@ -470,16 +364,14 @@ class StorageConnector {
       }
       const buffer = Buffer.concat(chunks);
 
-      // Verify fingerprint if provided
+      // Verify fingerprint if provided - using StorageCore
       if (expectedFingerprint) {
-        const actualFingerprint = this.generateFingerprint(buffer);
-
+        const actualFingerprint = this.core.calculateFingerprint(buffer);
         if (actualFingerprint !== expectedFingerprint) {
           throw new Error(
             `Fingerprint mismatch! Expected: ${expectedFingerprint}, Got: ${actualFingerprint}`
           );
         }
-
         this.logger.debug(`Fingerprint verified for ${bucket}/${path}`);
       }
 
@@ -530,11 +422,8 @@ class StorageConnector {
     try {
       bucket = bucket || this.defaultBucket;
 
-      const url = await this.client.presignedGetObject(
-        bucket,
-        path,
-        expiry
-      );
+      // Use StorageCore
+      const url = await this.core.getPresignedUrl(bucket, path, expiry);
 
       this.logger.debug(`Generated presigned URL for ${bucket}/${path}`);
       return url;
@@ -570,20 +459,25 @@ class StorageConnector {
     try {
       bucket = bucket || this.defaultBucket;
 
+      // Use StorageCore to list objects
+      const objectNames = await this.core.listByPrefix(bucket, prefix, true);
+
+      // Get metadata for each object
       const objects = [];
-      const stream = this.client.listObjectsV2(bucket, prefix, true);
-
-      for await (const obj of stream) {
-        // Get metadata for each object
-        const stat = await this.client.statObject(bucket, obj.name);
-
-        objects.push({
-          name: obj.name,
-          size: obj.size,
-          lastModified: obj.lastModified,
-          fingerprint: stat.metaData['x-amz-meta-fingerprint'],
-          uploadedAt: stat.metaData['x-amz-meta-uploaded-at']
-        });
+      for (const name of objectNames) {
+        try {
+          const stat = await this.core.statObject(bucket, name);
+          objects.push({
+            name,
+            size: stat.size,
+            lastModified: stat.lastModified,
+            fingerprint: stat.metaData?.['x-amz-meta-fingerprint'],
+            uploadedAt: stat.metaData?.['x-amz-meta-uploaded-at']
+          });
+        } catch (err) {
+          // Skip objects that can't be stat'd
+          this.logger.warn(`Failed to stat object ${name}`, err);
+        }
       }
 
       return objects;
@@ -614,7 +508,8 @@ class StorageConnector {
     try {
       bucket = bucket || this.defaultBucket;
 
-      await this.client.removeObject(bucket, path);
+      // Use StorageCore
+      await this.core.deleteObject(bucket, path);
       this.logger.warn(`Deleted object: ${bucket}/${path}`);
 
       // Clear from cache
@@ -688,10 +583,10 @@ class StorageConnector {
    */
   async ensureBucket(bucketName) {
     try {
-      const exists = await this.client.bucketExists(bucketName);
+      // Use StorageCore
+      const created = await this.core.ensureBucket(bucketName);
 
-      if (!exists) {
-        await this.client.makeBucket(bucketName, 'us-east-1');
+      if (created) {
         this.logger.info(`Bucket ${bucketName} created`);
       }
 
@@ -921,49 +816,6 @@ 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;
 

package/src/internal-url-adapter.js

@@ -4,34 +4,16 @@
  * Skrývá implementační detaily před službami
  */
 
+const fs = require('fs');
+const runtimeCfg = require('./config');
+
 class InternalUrlAdapter {
   constructor(config = {}) {
-    this.environment = config.environment || process.env.NODE_ENV || 'development';
-    this.dockerNetwork = config.dockerNetwork || process.env.DOCKER_NETWORK || false;
+    this.environment = runtimeCfg.get('nodeEnv', config.environment);
+    this.dockerNetwork = runtimeCfg.get('dockerNetwork', config.dockerNetwork);
 
     // Mapování služeb na jejich interní adresy
-    this.serviceMap = {
-      storage: {
-        docker: 'api_services_storage:9000',
-        local: 'localhost:9000'
-      },
-      registry: {
-        docker: 'api_registry:8080',
-        local: 'localhost:8080'
-      },
-      monitoring: {
-        docker: 'api_monitoring:3000',
-        local: 'localhost:3000'
-      },
-      mq: {
-        docker: 'api_services_rabbit:5672',
-        local: 'localhost:5672'
-      },
-      cache: {
-        docker: 'api_node_cache:6379',
-        local: 'localhost:6379'
-      }
-    };
+    this.serviceMap = { ...runtimeCfg.get('internalUrlServiceMap') };
 
     // Rozšiřitelné přes config
     if (config.services) {
@@ -91,11 +73,14 @@ class InternalUrlAdapter {
    */
   isRunningInDocker() {
     // Několik způsobů detekce Docker kontejneru
+    const dockerEnv = runtimeCfg.get('dockerEnv');
+    const dockerContainer = runtimeCfg.get('dockerContainer');
+    const hostname = runtimeCfg.get('hostname');
     return !!(
-      process.env.DOCKER_ENV ||
-      process.env.DOCKER_CONTAINER ||
-      (require('fs').existsSync('/.dockerenv')) ||
-      (process.env.HOSTNAME && process.env.HOSTNAME.length === 12) // Docker container ID
+      dockerEnv ||
+      dockerContainer ||
+      (fs.existsSync('/.dockerenv')) ||
+      (hostname && hostname.length === 12) // Docker container ID
     );
   }
 

package/tests/unit/internal-url-adapter.test.js

@@ -9,6 +9,8 @@ describe('InternalUrlAdapter @unit', () => {
 
   beforeEach(() => {
     adapter = new InternalUrlAdapter();
+    // Tests run inside a Docker container; force local-mode behavior unless explicitly enabled.
+    adapter.isRunningInDocker = jest.fn(() => false);
   });
 
   describe('URL Resolution', () => {
@@ -202,6 +204,8 @@ describe('InternalUrlAdapter @unit', () => {
         }
       });
 
+      // Tests run inside Docker; force local-mode behavior for this adapter instance.
+      customAdapter.isRunningInDocker = jest.fn(() => false);
       customAdapter.dockerNetwork = false;
       const resolved = customAdapter.resolve('internal://my-service/api');
 

package/tests/unit/storage.extended.unit.test.js

@@ -6,6 +6,14 @@
 const StorageConnector = require('../../src/index');
 const Minio = require('minio');
 
+// Minimal required MinIO config for tests (all external I/O is mocked)
+const MINIO_CONFIG = {
+  endPoint: 'localhost',
+  port: 9000,
+  accessKey: 'test',
+  secretKey: 'test',
+};
+
 // Mock MinIO client
 jest.mock('minio');
 
@@ -321,15 +329,15 @@ describe('StorageConnector Extended Unit Tests @unit', () => {
 
   describe('Internal URL Generation', () => {
     test('should generate abstract internal URL', () => {
-      storage = new StorageConnector();
+      storage = new StorageConnector(MINIO_CONFIG);
 
       const url = storage.getInternalUrl('bucket', 'path/to/object');
       expect(url).toBe('internal://storage/bucket/path/to/object');
     });
 
     test('should generate consistent internal URLs', () => {
-      const storage1 = new StorageConnector();
-      const storage2 = new StorageConnector();
+      const storage1 = new StorageConnector(MINIO_CONFIG);
+      const storage2 = new StorageConnector(MINIO_CONFIG);
 
       const url1 = storage1.getInternalUrl('bucket', 'object');
       const url2 = storage2.getInternalUrl('bucket', 'object');
@@ -341,7 +349,7 @@ describe('StorageConnector Extended Unit Tests @unit', () => {
 
   describe('Bucket Operations', () => {
     beforeEach(() => {
-      storage = new StorageConnector();
+      storage = new StorageConnector(MINIO_CONFIG);
     });
 
     test('should ensure bucket exists', async () => {
@@ -373,7 +381,7 @@ describe('StorageConnector Extended Unit Tests @unit', () => {
 
   describe('Cache Operations', () => {
     test('should clear all caches', () => {
-      storage = new StorageConnector();
+      storage = new StorageConnector(MINIO_CONFIG);
 
       // Add items to caches
       storage.cache.set('key1', 'value1');
@@ -389,7 +397,7 @@ describe('StorageConnector Extended Unit Tests @unit', () => {
     });
 
     test('should handle cache size limits', () => {
-      storage = new StorageConnector({ cacheMaxSize: 2 });
+      storage = new StorageConnector({ ...MINIO_CONFIG, cacheMaxSize: 2 });
 
       storage.addToCache('key1', 'value1');
       storage.addToCache('key2', 'value2');