@onlineapps/conn-base-storage 1.0.0

package/src/internal-url-adapter.js

@@ -0,0 +1,174 @@
+/**
+ * Internal URL Adapter
+ * Převádí abstraktní internal:// URL na skutečné endpointy
+ * Skrývá implementační detaily před službami
+ */
+
+class InternalUrlAdapter {
+  constructor(config = {}) {
+    this.environment = config.environment || process.env.NODE_ENV || 'development';
+    this.dockerNetwork = config.dockerNetwork || process.env.DOCKER_NETWORK || false;
+
+    // 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'
+      }
+    };
+
+    // Rozšiřitelné přes config
+    if (config.services) {
+      Object.assign(this.serviceMap, config.services);
+    }
+  }
+
+  /**
+   * Převede internal:// URL na skutečnou adresu
+   * @param {string} internalUrl - URL ve formátu internal://service/path
+   * @returns {string} Skutečná HTTP/HTTPS URL
+   */
+  resolve(internalUrl) {
+    if (!internalUrl || !internalUrl.startsWith('internal://')) {
+      return internalUrl; // Není internal URL, vrátíme jak je
+    }
+
+    // Parsování internal://service/path
+    const urlParts = internalUrl.replace('internal://', '').split('/');
+    const serviceName = urlParts[0];
+    const path = urlParts.slice(1).join('/');
+
+    // Najdeme mapování pro službu
+    const serviceConfig = this.serviceMap[serviceName];
+    if (!serviceConfig) {
+      throw new Error(`Unknown service: ${serviceName}`);
+    }
+
+    // Určíme endpoint podle prostředí
+    const isDocker = this.dockerNetwork || this.isRunningInDocker();
+    const endpoint = isDocker ? serviceConfig.docker : serviceConfig.local;
+
+    // Sestavíme skutečnou URL
+    return `http://${endpoint}/${path}`;
+  }
+
+  /**
+   * Převede skutečnou URL zpět na internal://
+   * @param {string} actualUrl - Skutečná HTTP URL
+   * @param {string} serviceName - Název služby
+   * @returns {string} Internal URL
+   */
+  toInternal(actualUrl, serviceName) {
+    if (!actualUrl || !serviceName) {
+      return actualUrl;
+    }
+
+    // Odstranit protokol a host
+    const url = new URL(actualUrl);
+    const path = url.pathname + url.search + url.hash;
+
+    return `internal://${serviceName}${path}`;
+  }
+
+  /**
+   * Detekce Docker prostředí
+   */
+  isRunningInDocker() {
+    // Několik způsobů detekce Docker kontejneru
+    return !!(
+      process.env.DOCKER_ENV ||
+      process.env.DOCKER_CONTAINER ||
+      (require('fs').existsSync('/.dockerenv')) ||
+      (process.env.HOSTNAME && process.env.HOSTNAME.length === 12) // Docker container ID
+    );
+  }
+
+  /**
+   * Middleware pro Express - automaticky resolvuje internal:// URL v odpovědích
+   */
+  expressMiddleware() {
+    return (req, res, next) => {
+      const originalJson = res.json;
+
+      res.json = (data) => {
+        // Rekurzivně projít response a nahradit internal:// URL
+        const transformed = this.transformResponse(data);
+        return originalJson.call(res, transformed);
+      };
+
+      next();
+    };
+  }
+
+  /**
+   * Rekurzivní transformace odpovědi
+   */
+  transformResponse(obj) {
+    if (typeof obj === 'string' && obj.startsWith('internal://')) {
+      return this.resolve(obj);
+    }
+
+    if (Array.isArray(obj)) {
+      return obj.map(item => this.transformResponse(item));
+    }
+
+    if (obj && typeof obj === 'object') {
+      const transformed = {};
+      for (const [key, value] of Object.entries(obj)) {
+        transformed[key] = this.transformResponse(value);
+      }
+      return transformed;
+    }
+
+    return obj;
+  }
+
+  /**
+   * HTTP client interceptor - automaticky resolvuje internal:// URL v požadavcích
+   */
+  axiosInterceptor(axios) {
+    axios.interceptors.request.use((config) => {
+      if (config.url && config.url.startsWith('internal://')) {
+        config.url = this.resolve(config.url);
+      }
+      return config;
+    });
+
+    return axios;
+  }
+
+  /**
+   * Získat všechny dostupné služby
+   */
+  getAvailableServices() {
+    return Object.keys(this.serviceMap);
+  }
+
+  /**
+   * Přidat nebo aktualizovat mapování služby
+   */
+  registerService(name, dockerEndpoint, localEndpoint) {
+    this.serviceMap[name] = {
+      docker: dockerEndpoint,
+      local: localEndpoint
+    };
+  }
+}
+
+module.exports = InternalUrlAdapter;

package/src/sharedUrlAdapter.js

@@ -0,0 +1,258 @@
+/**
+ * Shared URL Adapter
+ *
+ * Provides unified addressing for backend and frontend using shared:// protocol
+ *
+ * Examples:
+ *  - shared://registry/service-name/v1.0.0/spec.json
+ *  - shared://workflow/cookbook-123/step-1.json
+ *  - shared://storage/files/document.pdf
+ *
+ * Maps to MinIO buckets:
+ *  - registry -> registry bucket
+ *  - workflow -> workflow bucket
+ *  - storage -> default storage bucket
+ */
+
+class SharedUrlAdapter {
+  constructor(storageConnector) {
+    this.storage = storageConnector;
+
+    // Bucket mapping
+    this.bucketMap = {
+      'registry': 'registry',
+      'workflow': 'workflow',
+      'storage': 'api-storage',
+      'cache': 'cache',
+      'logs': 'logs'
+    };
+  }
+
+  /**
+   * Parse shared:// URL into components
+   * @param {string} sharedUrl - URL in format shared://bucket/path
+   * @returns {Object} { bucket, path, protocol }
+   */
+  parseSharedUrl(sharedUrl) {
+    if (!sharedUrl.startsWith('shared://')) {
+      throw new Error(`Invalid shared URL format. Must start with 'shared://'. Got: ${sharedUrl}`);
+    }
+
+    const urlPart = sharedUrl.substring(9); // Remove 'shared://'
+    const firstSlash = urlPart.indexOf('/');
+
+    if (firstSlash === -1) {
+      throw new Error(`Invalid shared URL format. Missing path. Got: ${sharedUrl}`);
+    }
+
+    const namespace = urlPart.substring(0, firstSlash);
+    const path = urlPart.substring(firstSlash + 1);
+
+    const bucket = this.bucketMap[namespace];
+    if (!bucket) {
+      throw new Error(`Unknown namespace '${namespace}'. Available: ${Object.keys(this.bucketMap).join(', ')}`);
+    }
+
+    return {
+      protocol: 'shared',
+      namespace,
+      bucket,
+      path,
+      originalUrl: sharedUrl
+    };
+  }
+
+  /**
+   * Convert shared:// URL to MinIO internal URL
+   * @param {string} sharedUrl
+   * @returns {string} MinIO URL
+   */
+  toMinioUrl(sharedUrl) {
+    const { bucket, path } = this.parseSharedUrl(sharedUrl);
+    return `s3://${bucket}/${path}`;
+  }
+
+  /**
+   * Convert shared:// URL to HTTP URL for external access
+   * @param {string} sharedUrl
+   * @returns {Promise<string>} Presigned HTTP URL
+   */
+  async toHttpUrl(sharedUrl, expiry = 3600) {
+    const { bucket, path } = this.parseSharedUrl(sharedUrl);
+
+    if (!this.storage) {
+      throw new Error('Storage connector not initialized');
+    }
+
+    return await this.storage.getPresignedUrl(bucket, path, expiry);
+  }
+
+  /**
+   * Upload content to shared:// URL
+   * @param {string} sharedUrl - Target URL
+   * @param {string|Buffer} content - Content to upload
+   * @returns {Promise<Object>} Upload result with fingerprint
+   */
+  async upload(sharedUrl, content) {
+    const { bucket, path } = this.parseSharedUrl(sharedUrl);
+
+    if (!this.storage) {
+      throw new Error('Storage connector not initialized');
+    }
+
+    // Ensure bucket exists
+    await this.storage.ensureBucket(bucket);
+
+    // For shared URLs, we want to use the exact path specified
+    // So we upload to the specific location instead of using fingerprinted names
+    const fingerprint = this.storage.generateFingerprint(content);
+
+    // Prepare content for upload
+    const data = Buffer.isBuffer(content) ? content : Buffer.from(content);
+
+    await this.storage.client.putObject(bucket, path, data, data.length, {
+      'Content-Type': path.endsWith('.json') ? 'application/json' : 'application/octet-stream',
+      'x-amz-meta-fingerprint': fingerprint
+    });
+
+    this.storage.logger.info(`Uploaded to shared://${bucket}/${path}`, {
+      bucket,
+      path,
+      fingerprint,
+      size: data.length
+    });
+
+    return {
+      bucket,
+      path,
+      fingerprint,
+      size: data.length,
+      sharedUrl
+    };
+  }
+
+  /**
+   * Download content from shared:// URL
+   * @param {string} sharedUrl - Source URL
+   * @param {string} [expectedFingerprint] - Optional fingerprint for verification
+   * @returns {Promise<string>} Downloaded content
+   */
+  async download(sharedUrl, expectedFingerprint = null) {
+    const { bucket, path } = this.parseSharedUrl(sharedUrl);
+
+    if (!this.storage) {
+      throw new Error('Storage connector not initialized');
+    }
+
+    if (expectedFingerprint) {
+      return await this.storage.downloadWithVerification(bucket, path, expectedFingerprint);
+    }
+
+    // Direct download without verification
+    const stream = await this.storage.client.getObject(bucket, path);
+    const chunks = [];
+
+    return new Promise((resolve, reject) => {
+      stream.on('data', chunk => chunks.push(chunk));
+      stream.on('error', reject);
+      stream.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+    });
+  }
+
+  /**
+   * List objects under shared:// path
+   * @param {string} sharedUrl - Base URL to list
+   * @returns {Promise<Array>} List of objects
+   */
+  async list(sharedUrl) {
+    const { bucket, path } = this.parseSharedUrl(sharedUrl);
+
+    if (!this.storage) {
+      throw new Error('Storage connector not initialized');
+    }
+
+    return await this.storage.listWithFingerprints(bucket, path);
+  }
+
+  /**
+   * Delete object at shared:// URL
+   * @param {string} sharedUrl - URL to delete
+   * @returns {Promise<boolean>} Success status
+   */
+  async delete(sharedUrl) {
+    const { bucket, path } = this.parseSharedUrl(sharedUrl);
+
+    if (!this.storage) {
+      throw new Error('Storage connector not initialized');
+    }
+
+    return await this.storage.deleteObject(bucket, path);
+  }
+
+  /**
+   * Check if shared:// URL exists
+   * @param {string} sharedUrl
+   * @returns {Promise<boolean>}
+   */
+  async exists(sharedUrl) {
+    const { bucket, path } = this.parseSharedUrl(sharedUrl);
+
+    if (!this.storage) {
+      throw new Error('Storage connector not initialized');
+    }
+
+    try {
+      await this.storage.client.statObject(bucket, path);
+      return true;
+    } catch (error) {
+      if (error.code === 'NotFound') {
+        return false;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Create a shared:// URL from components
+   * @param {string} namespace - Namespace (registry, workflow, storage)
+   * @param {string} path - Path within namespace
+   * @returns {string} Shared URL
+   */
+  createSharedUrl(namespace, path) {
+    if (!this.bucketMap[namespace]) {
+      throw new Error(`Unknown namespace '${namespace}'. Available: ${Object.keys(this.bucketMap).join(', ')}`);
+    }
+
+    // Ensure path doesn't start with /
+    const cleanPath = path.startsWith('/') ? path.substring(1) : path;
+
+    return `shared://${namespace}/${cleanPath}`;
+  }
+
+  /**
+   * Get metadata for shared:// URL
+   * @param {string} sharedUrl
+   * @returns {Promise<Object>} Object metadata
+   */
+  async getMetadata(sharedUrl) {
+    const { bucket, path } = this.parseSharedUrl(sharedUrl);
+
+    if (!this.storage) {
+      throw new Error('Storage connector not initialized');
+    }
+
+    const stat = await this.storage.client.statObject(bucket, path);
+
+    return {
+      size: stat.size,
+      etag: stat.etag,
+      lastModified: stat.lastModified,
+      metadata: stat.metaData,
+      sharedUrl,
+      bucket,
+      path
+    };
+  }
+}
+
+module.exports = SharedUrlAdapter;