@devicecloud.dev/dcd 4.2.0 → 4.2.2

package/dist/gateways/api-gateway.js

@@ -3,6 +3,34 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiGateway = void 0;
 const path = require("node:path");
 exports.ApiGateway = {
+    /**
+     * Enhances generic "fetch failed" errors with more specific diagnostic information
+     * @param error - The original TypeError from fetch
+     * @param url - The URL that was being fetched
+     * @returns Enhanced error with diagnostic information
+     */
+    enhanceFetchError(error, url) {
+        const urlObj = new URL(url);
+        const { hostname, origin } = urlObj;
+        let message = `Network request failed: ${url}\n\n`;
+        message += `Possible causes:\n`;
+        message += `  1. No internet connection - check your network connectivity\n`;
+        message += `  2. DNS resolution failed - unable to resolve "${hostname}"\n`;
+        message += `  3. Firewall or proxy blocking the request\n`;
+        message += `  4. API server is down or unreachable\n`;
+        message += `  5. SSL/TLS certificate validation failed\n\n`;
+        message += `Troubleshooting steps:\n`;
+        message += `  • Check internet connection: ping google.com\n`;
+        message += `  • Test API reachability: curl ${origin}\n`;
+        message += `  • Verify API URL is correct: ${origin}\n`;
+        message += `  • Check for proxy/VPN interference\n`;
+        message += `  • Try again in a few moments if server is temporarily down\n\n`;
+        message += `Original error: ${error.message}`;
+        const enhancedError = new Error(message);
+        enhancedError.name = 'NetworkError';
+        enhancedError.stack = error.stack;
+        return enhancedError;
+    },
     /**
      * Standardized error handling for API responses
      * @param res - The fetch response object
@@ -55,117 +83,169 @@ exports.ApiGateway = {
         }
     },
     async checkForExistingUpload(baseUrl, apiKey, sha) {
-        const res = await fetch(`${baseUrl}/uploads/checkForExistingUpload`, {
-            body: JSON.stringify({ sha }),
-            headers: {
-                'content-type': 'application/json',
-                'x-app-api-key': apiKey,
-            },
-            method: 'POST',
-        });
-        return res.json();
-    },
-    async downloadArtifactsZip(baseUrl, apiKey, uploadId, results, artifactsPath = './artifacts.zip') {
-        const res = await fetch(`${baseUrl}/results/${uploadId}/download`, {
-            body: JSON.stringify({ results }),
-            headers: {
-                'content-type': 'application/json',
-                'x-app-api-key': apiKey,
-            },
-            method: 'POST',
-        });
-        if (!res.ok) {
-            await this.handleApiError(res, 'Failed to download artifacts');
+        try {
+            const res = await fetch(`${baseUrl}/uploads/checkForExistingUpload`, {
+                body: JSON.stringify({ sha }),
+                headers: {
+                    'content-type': 'application/json',
+                    'x-app-api-key': apiKey,
+                },
+                method: 'POST',
+            });
+            if (!res.ok) {
+                await this.handleApiError(res, 'Failed to check for existing upload');
+            }
+            return res.json();
         }
-        // Handle tilde expansion for home directory
-        if (artifactsPath.startsWith('~/') || artifactsPath === '~') {
-            artifactsPath = artifactsPath.replace(/^~(?=$|\/|\\)/, 
-            // eslint-disable-next-line unicorn/prefer-module
-            require('node:os').homedir());
+        catch (error) {
+            // Handle network-level errors (DNS, connection refused, timeout, etc.)
+            if (error instanceof TypeError && error.message === 'fetch failed') {
+                throw this.enhanceFetchError(error, `${baseUrl}/uploads/checkForExistingUpload`);
+            }
+            throw error;
         }
-        // Create directory structure if it doesn't exist
-        // eslint-disable-next-line unicorn/prefer-module
-        const { dirname } = require('node:path');
-        // eslint-disable-next-line unicorn/prefer-module
-        const { createWriteStream, mkdirSync } = require('node:fs');
-        // eslint-disable-next-line unicorn/prefer-module
-        const { finished } = require('node:stream/promises');
-        // eslint-disable-next-line unicorn/prefer-module
-        const { Readable } = require('node:stream');
-        const directory = dirname(artifactsPath);
-        if (directory !== '.') {
-            try {
-                mkdirSync(directory, { recursive: true });
+    },
+    async downloadArtifactsZip(baseUrl, apiKey, uploadId, results, artifactsPath = './artifacts.zip') {
+        try {
+            const res = await fetch(`${baseUrl}/results/${uploadId}/download`, {
+                body: JSON.stringify({ results }),
+                headers: {
+                    'content-type': 'application/json',
+                    'x-app-api-key': apiKey,
+                },
+                method: 'POST',
+            });
+            if (!res.ok) {
+                await this.handleApiError(res, 'Failed to download artifacts');
+            }
+            // Handle tilde expansion for home directory
+            if (artifactsPath.startsWith('~/') || artifactsPath === '~') {
+                artifactsPath = artifactsPath.replace(/^~(?=$|\/|\\)/, 
+                // eslint-disable-next-line unicorn/prefer-module
+                require('node:os').homedir());
             }
-            catch (error) {
-                // Ignore if directory already exists
-                if (error.code !== 'EEXIST') {
-                    throw error;
+            // Create directory structure if it doesn't exist
+            // eslint-disable-next-line unicorn/prefer-module
+            const { dirname } = require('node:path');
+            // eslint-disable-next-line unicorn/prefer-module
+            const { createWriteStream, mkdirSync } = require('node:fs');
+            // eslint-disable-next-line unicorn/prefer-module
+            const { finished } = require('node:stream/promises');
+            // eslint-disable-next-line unicorn/prefer-module
+            const { Readable } = require('node:stream');
+            const directory = dirname(artifactsPath);
+            if (directory !== '.') {
+                try {
+                    mkdirSync(directory, { recursive: true });
+                }
+                catch (error) {
+                    // Ignore if directory already exists
+                    if (error.code !== 'EEXIST') {
+                        throw error;
+                    }
                 }
             }
+            const fileStream = createWriteStream(artifactsPath, { flags: 'w' });
+            await finished(Readable.fromWeb(res.body).pipe(fileStream));
+        }
+        catch (error) {
+            if (error instanceof TypeError && error.message === 'fetch failed') {
+                throw this.enhanceFetchError(error, `${baseUrl}/results/${uploadId}/download`);
+            }
+            throw error;
         }
-        const fileStream = createWriteStream(artifactsPath, { flags: 'w' });
-        await finished(Readable.fromWeb(res.body).pipe(fileStream));
     },
     async finaliseUpload(config) {
         const { baseUrl, apiKey, id, metadata, path, sha, supabaseSuccess, backblazeSuccess } = config;
-        const res = await fetch(`${baseUrl}/uploads/finaliseUpload`, {
-            body: JSON.stringify({
-                backblazeSuccess,
-                id,
-                metadata,
-                path, // This is tempPath for TUS uploads
-                sha,
-                supabaseSuccess,
-            }),
-            headers: {
-                'content-type': 'application/json',
-                'x-app-api-key': apiKey,
-            },
-            method: 'POST',
-        });
-        if (!res.ok) {
-            await this.handleApiError(res, 'Failed to finalize upload');
+        try {
+            const res = await fetch(`${baseUrl}/uploads/finaliseUpload`, {
+                body: JSON.stringify({
+                    backblazeSuccess,
+                    id,
+                    metadata,
+                    path, // This is tempPath for TUS uploads
+                    sha,
+                    supabaseSuccess,
+                }),
+                headers: {
+                    'content-type': 'application/json',
+                    'x-app-api-key': apiKey,
+                },
+                method: 'POST',
+            });
+            if (!res.ok) {
+                await this.handleApiError(res, 'Failed to finalize upload');
+            }
+            return res.json();
+        }
+        catch (error) {
+            if (error instanceof TypeError && error.message === 'fetch failed') {
+                throw this.enhanceFetchError(error, `${baseUrl}/uploads/finaliseUpload`);
+            }
+            throw error;
         }
-        return res.json();
     },
     async getBinaryUploadUrl(baseUrl, apiKey, platform, fileSize) {
-        const res = await fetch(`${baseUrl}/uploads/getBinaryUploadUrl`, {
-            body: JSON.stringify({ platform, fileSize }),
-            headers: {
-                'content-type': 'application/json',
-                'x-app-api-key': apiKey,
-            },
-            method: 'POST',
-        });
-        if (!res.ok) {
-            await this.handleApiError(res, 'Failed to get upload URL');
+        try {
+            const res = await fetch(`${baseUrl}/uploads/getBinaryUploadUrl`, {
+                body: JSON.stringify({ platform, fileSize }),
+                headers: {
+                    'content-type': 'application/json',
+                    'x-app-api-key': apiKey,
+                },
+                method: 'POST',
+            });
+            if (!res.ok) {
+                await this.handleApiError(res, 'Failed to get upload URL');
+            }
+            return res.json();
+        }
+        catch (error) {
+            if (error instanceof TypeError && error.message === 'fetch failed') {
+                throw this.enhanceFetchError(error, `${baseUrl}/uploads/getBinaryUploadUrl`);
+            }
+            throw error;
         }
-        return res.json();
     },
     async finishLargeFile(baseUrl, apiKey, fileId, partSha1Array) {
-        const res = await fetch(`${baseUrl}/uploads/finishLargeFile`, {
-            body: JSON.stringify({ fileId, partSha1Array }),
-            headers: {
-                'content-type': 'application/json',
-                'x-app-api-key': apiKey,
-            },
-            method: 'POST',
-        });
-        if (!res.ok) {
-            await this.handleApiError(res, 'Failed to finish large file');
+        try {
+            const res = await fetch(`${baseUrl}/uploads/finishLargeFile`, {
+                body: JSON.stringify({ fileId, partSha1Array }),
+                headers: {
+                    'content-type': 'application/json',
+                    'x-app-api-key': apiKey,
+                },
+                method: 'POST',
+            });
+            if (!res.ok) {
+                await this.handleApiError(res, 'Failed to finish large file');
+            }
+            return res.json();
+        }
+        catch (error) {
+            if (error instanceof TypeError && error.message === 'fetch failed') {
+                throw this.enhanceFetchError(error, `${baseUrl}/uploads/finishLargeFile`);
+            }
+            throw error;
         }
-        return res.json();
     },
     async getResultsForUpload(baseUrl, apiKey, uploadId) {
         // TODO: merge with getUploadStatus
-        const res = await fetch(`${baseUrl}/results/${uploadId}`, {
-            headers: { 'x-app-api-key': apiKey },
-        });
-        if (!res.ok) {
-            await this.handleApiError(res, 'Failed to get results');
+        try {
+            const res = await fetch(`${baseUrl}/results/${uploadId}`, {
+                headers: { 'x-app-api-key': apiKey },
+            });
+            if (!res.ok) {
+                await this.handleApiError(res, 'Failed to get results');
+            }
+            return res.json();
+        }
+        catch (error) {
+            if (error instanceof TypeError && error.message === 'fetch failed') {
+                throw this.enhanceFetchError(error, `${baseUrl}/results/${uploadId}`);
+            }
+            throw error;
         }
-        return res.json();
     },
     async getUploadStatus(baseUrl, apiKey, options) {
         const queryParams = new URLSearchParams();
@@ -175,28 +255,80 @@ exports.ApiGateway = {
         if (options.name) {
             queryParams.append('name', options.name);
         }
-        const response = await fetch(`${baseUrl}/uploads/status?${queryParams}`, {
-            headers: {
-                'x-app-api-key': apiKey,
-            },
-        });
-        if (!response.ok) {
-            await this.handleApiError(response, 'Failed to get upload status');
+        try {
+            const response = await fetch(`${baseUrl}/uploads/status?${queryParams}`, {
+                headers: {
+                    'x-app-api-key': apiKey,
+                },
+            });
+            if (!response.ok) {
+                await this.handleApiError(response, 'Failed to get upload status');
+            }
+            return response.json();
+        }
+        catch (error) {
+            if (error instanceof TypeError && error.message === 'fetch failed') {
+                throw this.enhanceFetchError(error, `${baseUrl}/uploads/status?${queryParams}`);
+            }
+            throw error;
+        }
+    },
+    async listUploads(baseUrl, apiKey, options = {}) {
+        const queryParams = new URLSearchParams();
+        if (options.name) {
+            queryParams.append('name', options.name);
+        }
+        if (options.from) {
+            queryParams.append('from', options.from);
+        }
+        if (options.to) {
+            queryParams.append('to', options.to);
+        }
+        if (options.limit !== undefined) {
+            queryParams.append('limit', String(options.limit));
+        }
+        if (options.offset !== undefined) {
+            queryParams.append('offset', String(options.offset));
+        }
+        const url = `${baseUrl}/uploads/list?${queryParams}`;
+        try {
+            const response = await fetch(url, {
+                headers: {
+                    'x-app-api-key': apiKey,
+                },
+            });
+            if (!response.ok) {
+                await this.handleApiError(response, 'Failed to list uploads');
+            }
+            return response.json();
+        }
+        catch (error) {
+            if (error instanceof TypeError && error.message === 'fetch failed') {
+                throw this.enhanceFetchError(error, url);
+            }
+            throw error;
         }
-        return response.json();
     },
     async uploadFlow(baseUrl, apiKey, testFormData) {
-        const res = await fetch(`${baseUrl}/uploads/flow`, {
-            body: testFormData,
-            headers: {
-                'x-app-api-key': apiKey,
-            },
-            method: 'POST',
-        });
-        if (!res.ok) {
-            await this.handleApiError(res, 'Failed to upload test flows');
+        try {
+            const res = await fetch(`${baseUrl}/uploads/flow`, {
+                body: testFormData,
+                headers: {
+                    'x-app-api-key': apiKey,
+                },
+                method: 'POST',
+            });
+            if (!res.ok) {
+                await this.handleApiError(res, 'Failed to upload test flows');
+            }
+            return res.json();
+        }
+        catch (error) {
+            if (error instanceof TypeError && error.message === 'fetch failed') {
+                throw this.enhanceFetchError(error, `${baseUrl}/uploads/flow`);
+            }
+            throw error;
         }
-        return res.json();
     },
     /**
      * Generic report download method that handles both junit and allure reports
@@ -232,51 +364,59 @@ exports.ApiGateway = {
         const { endpoint, defaultFilename, notFoundMessage, errorPrefix } = config[reportType];
         const finalReportPath = reportPath || path.resolve(process.cwd(), defaultFilename);
         const url = `${baseUrl}${endpoint}`;
-        // Make the download request
-        const res = await fetch(url, {
-            headers: {
-                'x-app-api-key': apiKey,
-            },
-            method: 'GET',
-        });
-        if (!res.ok) {
-            const errorText = await res.text();
-            if (res.status === 404) {
-                throw new Error(notFoundMessage);
+        try {
+            // Make the download request
+            const res = await fetch(url, {
+                headers: {
+                    'x-app-api-key': apiKey,
+                },
+                method: 'GET',
+            });
+            if (!res.ok) {
+                const errorText = await res.text();
+                if (res.status === 404) {
+                    throw new Error(notFoundMessage);
+                }
+                throw new Error(`${errorPrefix}: ${res.status} ${errorText}`);
             }
-            throw new Error(`${errorPrefix}: ${res.status} ${errorText}`);
-        }
-        // Handle tilde expansion for home directory (applies to all report types)
-        let expandedPath = finalReportPath;
-        if (finalReportPath.startsWith('~/') || finalReportPath === '~') {
-            expandedPath = finalReportPath.replace(/^~/, 
-            // eslint-disable-next-line unicorn/prefer-module
-            require('node:os').homedir());
-        }
-        // Create directory structure if it doesn't exist
-        // eslint-disable-next-line unicorn/prefer-module
-        const { dirname } = require('node:path');
-        // eslint-disable-next-line unicorn/prefer-module
-        const { createWriteStream, mkdirSync } = require('node:fs');
-        // eslint-disable-next-line unicorn/prefer-module
-        const { finished } = require('node:stream/promises');
-        // eslint-disable-next-line unicorn/prefer-module
-        const { Readable } = require('node:stream');
-        const directory = dirname(expandedPath);
-        if (directory !== '.') {
-            try {
-                mkdirSync(directory, { recursive: true });
+            // Handle tilde expansion for home directory (applies to all report types)
+            let expandedPath = finalReportPath;
+            if (finalReportPath.startsWith('~/') || finalReportPath === '~') {
+                expandedPath = finalReportPath.replace(/^~/, 
+                // eslint-disable-next-line unicorn/prefer-module
+                require('node:os').homedir());
             }
-            catch (error) {
-                // Ignore EEXIST errors (directory already exists)
-                if (error.code !== 'EEXIST') {
-                    throw error;
+            // Create directory structure if it doesn't exist
+            // eslint-disable-next-line unicorn/prefer-module
+            const { dirname } = require('node:path');
+            // eslint-disable-next-line unicorn/prefer-module
+            const { createWriteStream, mkdirSync } = require('node:fs');
+            // eslint-disable-next-line unicorn/prefer-module
+            const { finished } = require('node:stream/promises');
+            // eslint-disable-next-line unicorn/prefer-module
+            const { Readable } = require('node:stream');
+            const directory = dirname(expandedPath);
+            if (directory !== '.') {
+                try {
+                    mkdirSync(directory, { recursive: true });
+                }
+                catch (error) {
+                    // Ignore EEXIST errors (directory already exists)
+                    if (error.code !== 'EEXIST') {
+                        throw error;
+                    }
                 }
             }
+            // Write the file using streaming for better memory efficiency
+            // Use 'w' flag to overwrite existing files instead of failing
+            const fileStream = createWriteStream(expandedPath, { flags: 'w' });
+            await finished(Readable.fromWeb(res.body).pipe(fileStream));
+        }
+        catch (error) {
+            if (error instanceof TypeError && error.message === 'fetch failed') {
+                throw this.enhanceFetchError(error, url);
+            }
+            throw error;
         }
-        // Write the file using streaming for better memory efficiency
-        // Use 'w' flag to overwrite existing files instead of failing
-        const fileStream = createWriteStream(expandedPath, { flags: 'w' });
-        await finished(Readable.fromWeb(res.body).pipe(fileStream));
     },
 };