@coralogix/rum-cli 1.1.21 → 1.1.24

package/dist/services/dsym.service.d.ts

@@ -0,0 +1,3 @@
+export declare class DsymService {
+    static upload(application: string, version: string, repoName: string | undefined, commitHash: string | undefined, orgName: string | undefined, folderPath: string, env: string, privateKey: string): Promise<void>;
+}

package/dist/services/dsym.service.js

@@ -0,0 +1,36 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DsymService = void 0;
+const consts_1 = require("../consts/consts");
+const shared_utils_1 = require("../utils/shared.utils");
+const blobset_service_1 = require("../proto-models/com/coralogix/blobset/v2/blobset_service");
+const dsym_api_1 = require("../api/dsym.api");
+const file_processor_utils_1 = require("../utils/file-processor.utils");
+class DsymService {
+    static upload(application, version, repoName, commitHash, orgName, folderPath, env, privateKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const request = blobset_service_1.UploadBlobRequest.create();
+            console.log(consts_1.GRAY_COLOR, '🚀 Uploading Dsym...');
+            try {
+                yield file_processor_utils_1.FileProcessor.traverseDsymFolder(folderPath, request);
+                yield dsym_api_1.DsymApi.uploadDsym(request, application, version, repoName, commitHash, orgName, env, privateKey);
+                console.log(consts_1.GREEN_COLOR, '✅ Dsym uploaded successfully!');
+                console.log(consts_1.GREEN_COLOR, '✅ Processing complete.');
+            }
+            catch (error) {
+                (0, shared_utils_1.consoleError)(error);
+            }
+        });
+    }
+}
+exports.DsymService = DsymService;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/services/react-native.service.d.ts

@@ -0,0 +1,3 @@
+export declare class ReactNativeService {
+    static upload(application: string, version: string, repoName: string | undefined, commitHash: string | undefined, orgName: string | undefined, folderPath: string, env: string, privateKey: string): Promise<void>;
+}

package/dist/services/react-native.service.js

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReactNativeService = void 0;
+const consts_1 = require("../consts/consts");
+const shared_utils_1 = require("../utils/shared.utils");
+const react_native_api_1 = require("../api/react-native.api");
+const blobset_service_1 = require("../proto-models/com/coralogix/blobset/v2/blobset_service");
+const file_processor_utils_1 = require("../utils/file-processor.utils");
+class ReactNativeService {
+    static upload(application, version, repoName, commitHash, orgName, folderPath, env, privateKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const request = blobset_service_1.UploadBlobRequest.create();
+            console.log(consts_1.GRAY_COLOR, '🚀 Uploading react native source map...');
+            try {
+                const totalFiles = yield file_processor_utils_1.FileProcessor.traverseSourceMapsFolder(folderPath, '.map', request);
+                yield react_native_api_1.ReactNativeApi.uploadReactNativeSourceMaps(request, application, version, repoName, commitHash, orgName, env, privateKey);
+                console.log(consts_1.GREEN_COLOR, '✅ React native source map uploaded successfully!');
+                console.log(consts_1.GREEN_COLOR, `✅ Total files processed: ${totalFiles || 0}`);
+                console.log(consts_1.GREEN_COLOR, '✅ Processing complete.');
+            }
+            catch (error) {
+                (0, shared_utils_1.consoleError)(error);
+            }
+        });
+    }
+}
+exports.ReactNativeService = ReactNativeService;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/services/source-maps.service.js

@@ -11,9 +11,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SourceMapsService = void 0;
 const rum_source_map_service_1 = require("../proto-models/com/coralogix/rum/v2/rum_source_map_service");
-const rum_api_1 = require("../api/rum-api");
+const source_maps_api_1 = require("../api/source-maps.api");
 const consts_1 = require("../consts/consts");
-const utils_1 = require("../utils");
+const shared_utils_1 = require("../utils/shared.utils");
+const file_processor_utils_1 = require("../utils/file-processor.utils");
 class SourceMapsService {
     static upload(application, version, repoName, commitHash, orgName, folderPath, env, privateKey) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -25,15 +26,14 @@ class SourceMapsService {
             request.user = orgName;
             console.log(consts_1.GRAY_COLOR, '🚀 Uploading source maps...');
             try {
-                yield (0, utils_1.traverseFolder)(folderPath, request);
-                yield rum_api_1.RumApi.uploadSourceMaps(request, env, privateKey);
+                yield file_processor_utils_1.FileProcessor.traverseSourceMapsFolderOld(folderPath, request);
+                yield source_maps_api_1.SourceMapsApi.uploadSourceMaps(request, env, privateKey);
                 console.log(consts_1.GREEN_COLOR, '✅ Source maps uploaded successfully!');
                 console.log(consts_1.GREEN_COLOR, `✅ Total chunk files processed: ${request.files.length}`);
                 console.log(consts_1.GREEN_COLOR, '✅ Processing complete.');
             }
             catch (error) {
-                console.log(consts_1.RED_COLOR, '❌ An error occurred');
-                console.error(consts_1.RED_COLOR, error);
+                (0, shared_utils_1.consoleError)(error);
             }
         });
     }
@@ -48,15 +48,14 @@ class SourceMapsService {
             request.generate = generate;
             console.log(consts_1.GRAY_COLOR, '🔄 Updating source maps...');
             try {
-                yield (0, utils_1.traverseFolder)(folderPath, request);
-                yield rum_api_1.RumApi.updateSourceMap(request, env, privateKey);
+                yield file_processor_utils_1.FileProcessor.traverseSourceMapsFolderOld(folderPath, request);
+                yield source_maps_api_1.SourceMapsApi.updateSourceMap(request, env, privateKey);
                 console.log(consts_1.GREEN_COLOR, '✅ Source maps updated successfully!');
                 console.log(consts_1.GREEN_COLOR, `✅ Total chunk files processed: ${request.files.length}`);
                 console.log(consts_1.GREEN_COLOR, '✅ Processing complete.');
             }
             catch (error) {
-                console.log(consts_1.RED_COLOR, '❌ An error occurred');
-                console.error(consts_1.RED_COLOR, error);
+                (0, shared_utils_1.consoleError)(error);
             }
         });
     }
@@ -67,15 +66,14 @@ class SourceMapsService {
             request.releaseId = version;
             console.log(consts_1.GRAY_COLOR, '🗑️ Deleting source maps...');
             try {
-                yield rum_api_1.RumApi.deleteSourceMap(request, env, privateKey);
+                yield source_maps_api_1.SourceMapsApi.deleteSourceMap(request, env, privateKey);
                 console.log(consts_1.GREEN_COLOR, '✅ Source maps deleted successfully!');
             }
             catch (error) {
-                console.log(consts_1.RED_COLOR, '❌ An error occurred');
-                console.error(consts_1.RED_COLOR, error);
+                (0, shared_utils_1.consoleError)(error);
             }
         });
     }
 }
 exports.SourceMapsService = SourceMapsService;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic291cmNlLW1hcHMuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NlcnZpY2VzL3NvdXJjZS1tYXBzLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7O0FBQUEsd0dBSXFFO0FBQ3JFLDREQUF1RDtBQUN2RCw2Q0FBMkQ7QUFDM0Qsd0RBQXFEO0FBQ3JELHdFQUE4RDtBQUU5RCxNQUFhLGlCQUFpQjtJQUM1QixNQUFNLENBQU8sTUFBTSxDQUNqQixXQUFtQixFQUNuQixPQUFlLEVBQ2YsUUFBNEIsRUFDNUIsVUFBOEIsRUFDOUIsT0FBMkIsRUFDM0IsVUFBa0IsRUFDbEIsR0FBVyxFQUNYLFVBQWtCOztZQUVsQixNQUFNLE9BQU8sR0FBRyxnREFBdUIsQ0FBQyxNQUFNLEVBQUUsQ0FBQztZQUVqRCxPQUFPLENBQUMsV0FBVyxHQUFHLFdBQVcsQ0FBQztZQUNsQyxPQUFPLENBQUMsU0FBUyxHQUFHLE9BQU8sQ0FBQztZQUM1QixPQUFPLENBQUMsUUFBUSxHQUFHLFFBQVEsQ0FBQztZQUM1QixPQUFPLENBQUMsVUFBVSxHQUFHLFVBQVUsQ0FBQztZQUNoQyxPQUFPLENBQUMsSUFBSSxHQUFHLE9BQU8sQ0FBQztZQUV2QixPQUFPLENBQUMsR0FBRyxDQUFDLG1CQUFVLEVBQUUsNkJBQTZCLENBQUMsQ0FBQztZQUV2RCxJQUFJO2dCQUNGLE1BQU0sb0NBQWEsQ0FBQywyQkFBMkIsQ0FBQyxVQUFVLEVBQUUsT0FBTyxDQUFDLENBQUM7Z0JBRXJFLE1BQU0sK0JBQWEsQ0FBQyxnQkFBZ0IsQ0FBQyxPQUFPLEVBQUUsR0FBRyxFQUFFLFVBQVUsQ0FBQyxDQUFDO2dCQUUvRCxPQUFPLENBQUMsR0FBRyxDQUFDLG9CQUFXLEVBQUUsc0NBQXNDLENBQUMsQ0FBQztnQkFDakUsT0FBTyxDQUFDLEdBQUcsQ0FBQyxvQkFBVyxFQUFFLGtDQUFrQyxPQUFPLENBQUMsS0FBSyxDQUFDLE1BQU0sRUFBRSxDQUFDLENBQUM7Z0JBQ25GLE9BQU8sQ0FBQyxHQUFHLENBQUMsb0JBQVcsRUFBRSx3QkFBd0IsQ0FBQyxDQUFDO2FBQ3BEO1lBQUMsT0FBTyxLQUFLLEVBQUU7Z0JBQ2QsSUFBQSwyQkFBWSxFQUFDLEtBQUssQ0FBQyxDQUFDO2FBQ3JCO1FBQ0gsQ0FBQztLQUFBO0lBRUQsTUFBTSxDQUFPLE1BQU0sQ0FDakIsV0FBbUIsRUFDbkIsT0FBZSxFQUNmLFFBQTRCLEVBQzVCLFVBQThCLEVBQzlCLE9BQTJCLEVBQzNCLFVBQWtCLEVBQ2xCLFFBQTRCLEVBQzVCLEdBQVcsRUFDWCxVQUFrQjs7WUFFbEIsTUFBTSxPQUFPLEdBQUcsK0NBQXNCLENBQUMsTUFBTSxFQUFFLENBQUM7WUFFaEQsT0FBTyxDQUFDLFdBQVcsR0FBRyxXQUFXLENBQUM7WUFDbEMsT0FBTyxDQUFDLFNBQVMsR0FBRyxPQUFPLENBQUM7WUFDNUIsT0FBTyxDQUFDLFFBQVEsR0FBRyxRQUFRLENBQUM7WUFDNUIsT0FBTyxDQUFDLFVBQVUsR0FBRyxVQUFVLENBQUM7WUFDaEMsT0FBTyxDQUFDLElBQUksR0FBRyxPQUFPLENBQUM7WUFDdkIsT0FBTyxDQUFDLFFBQVEsR0FBRyxRQUFRLENBQUM7WUFFNUIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxtQkFBVSxFQUFFLDRCQUE0QixDQUFDLENBQUM7WUFFdEQsSUFBSTtnQkFDRixNQUFNLG9DQUFhLENBQUMsMkJBQTJCLENBQUMsVUFBVSxFQUFFLE9BQU8sQ0FBQyxDQUFDO2dCQUVyRSxNQUFNLCtCQUFhLENBQUMsZUFBZSxDQUFDLE9BQU8sRUFBRSxHQUFHLEVBQUUsVUFBVSxDQUFDLENBQUM7Z0JBRTlELE9BQU8sQ0FBQyxHQUFHLENBQUMsb0JBQVcsRUFBRSxxQ0FBcUMsQ0FBQyxDQUFDO2dCQUNoRSxPQUFPLENBQUMsR0FBRyxDQUFDLG9CQUFXLEVBQUUsa0NBQWtDLE9BQU8sQ0FBQyxLQUFLLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQztnQkFDbkYsT0FBTyxDQUFDLEdBQUcsQ0FBQyxvQkFBVyxFQUFFLHdCQUF3QixDQUFDLENBQUM7YUFDcEQ7WUFBQyxPQUFPLEtBQUssRUFBRTtnQkFDZCxJQUFBLDJCQUFZLEVBQUMsS0FBSyxDQUFDLENBQUM7YUFDckI7UUFDSCxDQUFDO0tBQUE7SUFFRCxNQUFNLENBQU8sTUFBTSxDQUFDLFdBQW1CLEVBQUUsT0FBZSxFQUFFLEdBQVcsRUFBRSxVQUFrQjs7WUFDdkYsTUFBTSxPQUFPLEdBQUcsK0NBQXNCLENBQUMsTUFBTSxFQUFFLENBQUM7WUFFaEQsT0FBTyxDQUFDLFdBQVcsR0FBRyxXQUFXLENBQUM7WUFDbEMsT0FBTyxDQUFDLFNBQVMsR0FBRyxPQUFPLENBQUM7WUFFNUIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxtQkFBVSxFQUFFLDZCQUE2QixDQUFDLENBQUM7WUFFdkQsSUFBSTtnQkFDRixNQUFNLCtCQUFhLENBQUMsZUFBZSxDQUFDLE9BQU8sRUFBRSxHQUFHLEVBQUUsVUFBVSxDQUFDLENBQUM7Z0JBRTlELE9BQU8sQ0FBQyxHQUFHLENBQUMsb0JBQVcsRUFBRSxxQ0FBcUMsQ0FBQyxDQUFDO2FBQ2pFO1lBQUMsT0FBTyxLQUFLLEVBQUU7Z0JBQ2QsSUFBQSwyQkFBWSxFQUFDLEtBQUssQ0FBQyxDQUFDO2FBQ3JCO1FBQ0gsQ0FBQztLQUFBO0NBQ0Y7QUFyRkQsOENBcUZDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgRGVsZXRlU291cmNlTWFwUmVxdWVzdCxcbiAgVXBkYXRlU291cmNlTWFwUmVxdWVzdCxcbiAgVXBsb2FkU291cmNlTWFwc1JlcXVlc3QsXG59IGZyb20gJy4uL3Byb3RvLW1vZGVscy9jb20vY29yYWxvZ2l4L3J1bS92Mi9ydW1fc291cmNlX21hcF9zZXJ2aWNlJztcbmltcG9ydCB7IFNvdXJjZU1hcHNBcGkgfSBmcm9tICcuLi9hcGkvc291cmNlLW1hcHMuYXBpJztcbmltcG9ydCB7IEdSQVlfQ09MT1IsIEdSRUVOX0NPTE9SIH0gZnJvbSAnLi4vY29uc3RzL2NvbnN0cyc7XG5pbXBvcnQgeyBjb25zb2xlRXJyb3IgfSBmcm9tICcuLi91dGlscy9zaGFyZWQudXRpbHMnO1xuaW1wb3J0IHsgRmlsZVByb2Nlc3NvciB9IGZyb20gJy4uL3V0aWxzL2ZpbGUtcHJvY2Vzc29yLnV0aWxzJztcblxuZXhwb3J0IGNsYXNzIFNvdXJjZU1hcHNTZXJ2aWNlIHtcbiAgc3RhdGljIGFzeW5jIHVwbG9hZChcbiAgICBhcHBsaWNhdGlvbjogc3RyaW5nLFxuICAgIHZlcnNpb246IHN0cmluZyxcbiAgICByZXBvTmFtZTogc3RyaW5nIHwgdW5kZWZpbmVkLFxuICAgIGNvbW1pdEhhc2g6IHN0cmluZyB8IHVuZGVmaW5lZCxcbiAgICBvcmdOYW1lOiBzdHJpbmcgfCB1bmRlZmluZWQsXG4gICAgZm9sZGVyUGF0aDogc3RyaW5nLFxuICAgIGVudjogc3RyaW5nLFxuICAgIHByaXZhdGVLZXk6IHN0cmluZyxcbiAgKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgY29uc3QgcmVxdWVzdCA9IFVwbG9hZFNvdXJjZU1hcHNSZXF1ZXN0LmNyZWF0ZSgpO1xuXG4gICAgcmVxdWVzdC5hcHBsaWNhdGlvbiA9IGFwcGxpY2F0aW9uO1xuICAgIHJlcXVlc3QucmVsZWFzZUlkID0gdmVyc2lvbjtcbiAgICByZXF1ZXN0LnJlcG9OYW1lID0gcmVwb05hbWU7XG4gICAgcmVxdWVzdC5jb21taXRIYXNoID0gY29tbWl0SGFzaDtcbiAgICByZXF1ZXN0LnVzZXIgPSBvcmdOYW1lO1xuXG4gICAgY29uc29sZS5sb2coR1JBWV9DT0xPUiwgJ/CfmoAgVXBsb2FkaW5nIHNvdXJjZSBtYXBzLi4uJyk7XG5cbiAgICB0cnkge1xuICAgICAgYXdhaXQgRmlsZVByb2Nlc3Nvci50cmF2ZXJzZVNvdXJjZU1hcHNGb2xkZXJPbGQoZm9sZGVyUGF0aCwgcmVxdWVzdCk7XG5cbiAgICAgIGF3YWl0IFNvdXJjZU1hcHNBcGkudXBsb2FkU291cmNlTWFwcyhyZXF1ZXN0LCBlbnYsIHByaXZhdGVLZXkpO1xuXG4gICAgICBjb25zb2xlLmxvZyhHUkVFTl9DT0xPUiwgJ+KchSBTb3VyY2UgbWFwcyB1cGxvYWRlZCBzdWNjZXNzZnVsbHkhJyk7XG4gICAgICBjb25zb2xlLmxvZyhHUkVFTl9DT0xPUiwgYOKchSBUb3RhbCBjaHVuayBmaWxlcyBwcm9jZXNzZWQ6ICR7cmVxdWVzdC5maWxlcy5sZW5ndGh9YCk7XG4gICAgICBjb25zb2xlLmxvZyhHUkVFTl9DT0xPUiwgJ+KchSBQcm9jZXNzaW5nIGNvbXBsZXRlLicpO1xuICAgIH0gY2F0Y2ggKGVycm9yKSB7XG4gICAgICBjb25zb2xlRXJyb3IoZXJyb3IpO1xuICAgIH1cbiAgfVxuXG4gIHN0YXRpYyBhc3luYyB1cGRhdGUoXG4gICAgYXBwbGljYXRpb246IHN0cmluZyxcbiAgICB2ZXJzaW9uOiBzdHJpbmcsXG4gICAgcmVwb05hbWU6IHN0cmluZyB8IHVuZGVmaW5lZCxcbiAgICBjb21taXRIYXNoOiBzdHJpbmcgfCB1bmRlZmluZWQsXG4gICAgb3JnTmFtZTogc3RyaW5nIHwgdW5kZWZpbmVkLFxuICAgIGZvbGRlclBhdGg6IHN0cmluZyxcbiAgICBnZW5lcmF0ZTogc3RyaW5nIHwgdW5kZWZpbmVkLFxuICAgIGVudjogc3RyaW5nLFxuICAgIHByaXZhdGVLZXk6IHN0cmluZyxcbiAgKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgY29uc3QgcmVxdWVzdCA9IFVwZGF0ZVNvdXJjZU1hcFJlcXVlc3QuY3JlYXRlKCk7XG5cbiAgICByZXF1ZXN0LmFwcGxpY2F0aW9uID0gYXBwbGljYXRpb247XG4gICAgcmVxdWVzdC5yZWxlYXNlSWQgPSB2ZXJzaW9uO1xuICAgIHJlcXVlc3QucmVwb05hbWUgPSByZXBvTmFtZTtcbiAgICByZXF1ZXN0LmNvbW1pdEhhc2ggPSBjb21taXRIYXNoO1xuICAgIHJlcXVlc3QudXNlciA9IG9yZ05hbWU7XG4gICAgcmVxdWVzdC5nZW5lcmF0ZSA9IGdlbmVyYXRlO1xuXG4gICAgY29uc29sZS5sb2coR1JBWV9DT0xPUiwgJ/CflIQgVXBkYXRpbmcgc291cmNlIG1hcHMuLi4nKTtcblxuICAgIHRyeSB7XG4gICAgICBhd2FpdCBGaWxlUHJvY2Vzc29yLnRyYXZlcnNlU291cmNlTWFwc0ZvbGRlck9sZChmb2xkZXJQYXRoLCByZXF1ZXN0KTtcblxuICAgICAgYXdhaXQgU291cmNlTWFwc0FwaS51cGRhdGVTb3VyY2VNYXAocmVxdWVzdCwgZW52LCBwcml2YXRlS2V5KTtcblxuICAgICAgY29uc29sZS5sb2coR1JFRU5fQ09MT1IsICfinIUgU291cmNlIG1hcHMgdXBkYXRlZCBzdWNjZXNzZnVsbHkhJyk7XG4gICAgICBjb25zb2xlLmxvZyhHUkVFTl9DT0xPUiwgYOKchSBUb3RhbCBjaHVuayBmaWxlcyBwcm9jZXNzZWQ6ICR7cmVxdWVzdC5maWxlcy5sZW5ndGh9YCk7XG4gICAgICBjb25zb2xlLmxvZyhHUkVFTl9DT0xPUiwgJ+KchSBQcm9jZXNzaW5nIGNvbXBsZXRlLicpO1xuICAgIH0gY2F0Y2ggKGVycm9yKSB7XG4gICAgICBjb25zb2xlRXJyb3IoZXJyb3IpO1xuICAgIH1cbiAgfVxuXG4gIHN0YXRpYyBhc3luYyBkZWxldGUoYXBwbGljYXRpb246IHN0cmluZywgdmVyc2lvbjogc3RyaW5nLCBlbnY6IHN0cmluZywgcHJpdmF0ZUtleTogc3RyaW5nKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgY29uc3QgcmVxdWVzdCA9IERlbGV0ZVNvdXJjZU1hcFJlcXVlc3QuY3JlYXRlKCk7XG5cbiAgICByZXF1ZXN0LmFwcGxpY2F0aW9uID0gYXBwbGljYXRpb247XG4gICAgcmVxdWVzdC5yZWxlYXNlSWQgPSB2ZXJzaW9uO1xuXG4gICAgY29uc29sZS5sb2coR1JBWV9DT0xPUiwgJ/Cfl5HvuI8gRGVsZXRpbmcgc291cmNlIG1hcHMuLi4nKTtcblxuICAgIHRyeSB7XG4gICAgICBhd2FpdCBTb3VyY2VNYXBzQXBpLmRlbGV0ZVNvdXJjZU1hcChyZXF1ZXN0LCBlbnYsIHByaXZhdGVLZXkpO1xuXG4gICAgICBjb25zb2xlLmxvZyhHUkVFTl9DT0xPUiwgJ+KchSBTb3VyY2UgbWFwcyBkZWxldGVkIHN1Y2Nlc3NmdWxseSEnKTtcbiAgICB9IGNhdGNoIChlcnJvcikge1xuICAgICAgY29uc29sZUVycm9yKGVycm9yKTtcbiAgICB9XG4gIH1cbn1cbiJdfQ==

package/dist/utils/file-processor.utils.d.ts

@@ -0,0 +1,12 @@
+import { UploadBlobRequest } from '../proto-models/com/coralogix/blobset/v2/blobset_service';
+import { UploadSourceMapsRequest } from '../proto-models/com/coralogix/rum/v2/rum_source_map_service';
+export declare class FileProcessor {
+    static traverseDsymFolder(folderPath: string, request: UploadBlobRequest): Promise<void>;
+    static traverseSourceMapsFolder(folderPath: string, fileExtension: string, request: UploadBlobRequest): Promise<number | undefined>;
+    private static processSourceMapSingleFile;
+    private static processSourceMapDirectory;
+    private static getDwarfPath;
+    static traverseSourceMapsFolderOld(folderPath: string, request: UploadSourceMapsRequest): Promise<void>;
+    static compressFileContentChunks(fileContent: Uint8Array): Uint8Array;
+    private static getFileMetadata;
+}

package/dist/utils/file-processor.utils.js

@@ -0,0 +1,196 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileProcessor = void 0;
+const fs = __importStar(require("fs"));
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const zlib_1 = __importDefault(require("zlib"));
+const shared_utils_1 = require("./shared.utils");
+const config_1 = __importDefault(require("../config"));
+const pako_1 = __importDefault(require("pako"));
+const consts_1 = require("../consts/consts");
+const { readdir, stat, readFile } = fs_1.promises;
+class FileProcessor {
+    static traverseDsymFolder(folderPath, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const processDsymFolder = (dsymFolderPath) => __awaiter(this, void 0, void 0, function* () {
+                    const dwarfPath = yield FileProcessor.getDwarfPath(dsymFolderPath);
+                    const content = yield readFile(dwarfPath);
+                    const compressedContent = zlib_1.default.gzipSync(content);
+                    request.data = new Uint8Array(compressedContent);
+                });
+                // Check if the folder itself is a .dSYM folder
+                if (folderPath.endsWith('.dSYM')) {
+                    yield processDsymFolder(folderPath);
+                    return;
+                }
+                const files = yield readdir(folderPath, { withFileTypes: true });
+                for (const file of files) {
+                    // Skip .DS_Store and hidden files
+                    if (file.name === '.DS_Store' || file.name.startsWith('.')) {
+                        continue;
+                    }
+                    const filePath = path.join(folderPath, file.name);
+                    if (file.isDirectory()) {
+                        if (file.name.endsWith('.dSYM')) {
+                            yield processDsymFolder(filePath);
+                            return;
+                        }
+                        else {
+                            yield FileProcessor.traverseDsymFolder(filePath, request);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                (0, shared_utils_1.consoleError)(`Error traversing directory: ${JSON.stringify(error)}`);
+            }
+        });
+    }
+    static traverseSourceMapsFolder(folderPath, fileExtension, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const stats = yield stat(folderPath);
+                if (stats.isFile() && folderPath.endsWith(fileExtension)) {
+                    return yield this.processSourceMapSingleFile(folderPath, fileExtension, request);
+                }
+                else if (stats.isDirectory()) {
+                    return yield this.processSourceMapDirectory(folderPath, fileExtension, request);
+                }
+            }
+            catch (error) {
+                (0, shared_utils_1.consoleError)(`Error traversing directory: ${error}`);
+            }
+        });
+    }
+    static processSourceMapSingleFile(filePath, fileExtension, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const content = yield readFile(filePath);
+                const { name } = path.parse(filePath);
+                const fileData = { name, content: content.toString('base64') };
+                const compressedContent = zlib_1.default.gzipSync(Buffer.from(JSON.stringify([fileData])));
+                request.data = new Uint8Array(compressedContent);
+                return 1;
+            }
+            catch (error) {
+                (0, shared_utils_1.consoleError)(`Error processing file: ${error}`);
+                throw error;
+            }
+        });
+    }
+    static processSourceMapDirectory(folderPath, fileExtension, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const files = yield readdir(folderPath, { withFileTypes: true });
+            const fileDataList = [];
+            for (const dirent of files) {
+                const filePath = path.join(folderPath, dirent.name);
+                if (dirent.isFile() && dirent.name.endsWith(fileExtension)) {
+                    const content = yield readFile(filePath);
+                    const { name } = path.parse(filePath);
+                    fileDataList.push({ name, content: content.toString('base64') });
+                }
+                else if (dirent.isDirectory()) {
+                    yield this.traverseSourceMapsFolder(filePath, fileExtension, request);
+                }
+            }
+            const compressedContent = zlib_1.default.gzipSync(Buffer.from(JSON.stringify(fileDataList)));
+            request.data = new Uint8Array(compressedContent);
+            return fileDataList.length;
+        });
+    }
+    static getDwarfPath(dsymPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dwarfPath = 'Contents/Resources/DWARF';
+            const targetPath = path.join(dsymPath, dwarfPath);
+            const files = fs.readdirSync(targetPath);
+            if (files.length === 1) {
+                return path.join(dsymPath, dwarfPath, files[0]);
+            }
+            else {
+                (0, shared_utils_1.consoleError)(`Expected exactly one file in the directory, but found: ${files.length}`);
+                return '';
+            }
+        });
+    }
+    static traverseSourceMapsFolderOld(folderPath, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stack = [folderPath];
+            while (stack.length) {
+                const currentPath = stack.pop();
+                const entries = yield readdir(currentPath, { withFileTypes: true });
+                yield Promise.all(entries.map((file) => __awaiter(this, void 0, void 0, function* () {
+                    const { name } = file;
+                    const entryPath = path.join(currentPath, name);
+                    const isCorrectSuffix = file.isFile() && name.endsWith('.js.map');
+                    if (file.isDirectory())
+                        stack.push(entryPath);
+                    else if (isCorrectSuffix)
+                        request.files.push(yield FileProcessor.getFileMetadata(entryPath));
+                })));
+            }
+        });
+    }
+    static compressFileContentChunks(fileContent) {
+        const { chunkSize } = config_1.default.rumApi; // 512 KB chunk size
+        const deflate = new pako_1.default.Deflate();
+        const totalChunks = Math.ceil(fileContent.length / chunkSize);
+        for (let i = 0; i < totalChunks; i++) {
+            const start = i * chunkSize;
+            const end = start + chunkSize;
+            const chunk = fileContent.subarray(start, end);
+            const isLastChunk = i === totalChunks - 1;
+            deflate.push(chunk, isLastChunk);
+        }
+        const { err, msg, result } = deflate;
+        if (err)
+            console.error(consts_1.RED_COLOR, msg);
+        return result;
+    }
+    static getFileMetadata(filePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { size } = yield stat(filePath);
+            const { name } = path.parse(filePath);
+            const content = yield readFile(filePath);
+            return { chunkName: name, size, content };
+        });
+    }
+}
+exports.FileProcessor = FileProcessor;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-processor.utils.js","sourceRoot":"","sources":["../../utils/file-processor.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport { Dirent, promises as fsPromises } from 'fs';\nimport * as path from 'path';\nimport zlib from 'zlib';\nimport { consoleError } from './shared.utils';\nimport { UploadBlobRequest } from '../proto-models/com/coralogix/blobset/v2/blobset_service';\nimport { UploadSourceMapsRequest } from '../proto-models/com/coralogix/rum/v2/rum_source_map_service';\nimport config from '../config';\nimport pako from 'pako';\nimport { FileMetadata } from '../proto-models/com/coralogix/rum/v2/file';\nimport { RED_COLOR } from '../consts/consts';\n\nconst { readdir, stat, readFile } = fsPromises;\n\nexport class FileProcessor {\n  static async traverseDsymFolder(folderPath: string, request: UploadBlobRequest): Promise<void> {\n    try {\n      const processDsymFolder = async (dsymFolderPath: string) => {\n        const dwarfPath = await FileProcessor.getDwarfPath(dsymFolderPath);\n        const content = await readFile(dwarfPath);\n        const compressedContent = zlib.gzipSync(content);\n        request.data = new Uint8Array(compressedContent);\n      };\n\n      // Check if the folder itself is a .dSYM folder\n      if (folderPath.endsWith('.dSYM')) {\n        await processDsymFolder(folderPath);\n        return;\n      }\n\n      const files: Dirent[] = await readdir(folderPath, { withFileTypes: true });\n\n      for (const file of files) {\n        // Skip .DS_Store and hidden files\n        if (file.name === '.DS_Store' || file.name.startsWith('.')) {\n          continue;\n        }\n\n        const filePath: string = path.join(folderPath, file.name);\n\n        if (file.isDirectory()) {\n          if (file.name.endsWith('.dSYM')) {\n            await processDsymFolder(filePath);\n            return;\n          } else {\n            await FileProcessor.traverseDsymFolder(filePath, request);\n          }\n        }\n      }\n    } catch (error) {\n      consoleError(`Error traversing directory: ${JSON.stringify(error)}`);\n    }\n  }\n\n  static async traverseSourceMapsFolder(\n    folderPath: string,\n    fileExtension: string,\n    request: UploadBlobRequest,\n  ): Promise<number | undefined> {\n    try {\n      const stats = await stat(folderPath);\n\n      if (stats.isFile() && folderPath.endsWith(fileExtension)) {\n        return await this.processSourceMapSingleFile(folderPath, fileExtension, request);\n      } else if (stats.isDirectory()) {\n        return await this.processSourceMapDirectory(folderPath, fileExtension, request);\n      }\n    } catch (error) {\n      consoleError(`Error traversing directory: ${error}`);\n    }\n  }\n\n  private static async processSourceMapSingleFile(filePath: string, fileExtension: string, request: UploadBlobRequest): Promise<number> {\n    try {\n      const content = await readFile(filePath);\n\n      const { name } = path.parse(filePath);\n\n      const fileData = { name, content: content.toString('base64') };\n\n      const compressedContent = zlib.gzipSync(Buffer.from(JSON.stringify([fileData])));\n\n      request.data = new Uint8Array(compressedContent);\n\n      return 1;\n    } catch (error) {\n      consoleError(`Error processing file: ${error}`);\n      throw error;\n    }\n  }\n\n  private static async processSourceMapDirectory(folderPath: string, fileExtension: string, request: UploadBlobRequest): Promise<number> {\n    const files = await readdir(folderPath, { withFileTypes: true });\n    const fileDataList: { name: string; content: string }[] = [];\n\n    for (const dirent of files) {\n      const filePath = path.join(folderPath, dirent.name);\n\n      if (dirent.isFile() && dirent.name.endsWith(fileExtension)) {\n        const content = await readFile(filePath);\n        const { name } = path.parse(filePath);\n        fileDataList.push({ name, content: content.toString('base64') });\n      } else if (dirent.isDirectory()) {\n        await this.traverseSourceMapsFolder(filePath, fileExtension, request);\n      }\n    }\n\n    const compressedContent = zlib.gzipSync(Buffer.from(JSON.stringify(fileDataList)));\n\n    request.data = new Uint8Array(compressedContent);\n\n    return fileDataList.length;\n  }\n\n  private static async getDwarfPath(dsymPath: string): Promise<string> {\n    const dwarfPath: string = 'Contents/Resources/DWARF';\n    const targetPath: string = path.join(dsymPath, dwarfPath);\n    const files = fs.readdirSync(targetPath);\n    if (files.length === 1) {\n      return path.join(dsymPath, dwarfPath, files[0]);\n    } else {\n      consoleError(`Expected exactly one file in the directory, but found: ${files.length}`);\n      return '';\n    }\n  }\n\n  static async traverseSourceMapsFolderOld(folderPath: string, request: UploadSourceMapsRequest): Promise<void> {\n    const stack: string[] = [folderPath];\n\n    while (stack.length) {\n      const currentPath = stack.pop();\n      const entries: Dirent[] = await readdir(currentPath!, { withFileTypes: true });\n\n      await Promise.all(\n        entries.map(async (file: Dirent) => {\n          const { name } = file;\n          const entryPath = path.join(currentPath as string, name);\n          const isCorrectSuffix = file.isFile() && name.endsWith('.js.map');\n\n          if (file.isDirectory()) stack.push(entryPath);\n          else if (isCorrectSuffix) request.files.push(await FileProcessor.getFileMetadata(entryPath));\n        }),\n      );\n    }\n  }\n\n  static compressFileContentChunks(fileContent: Uint8Array): Uint8Array {\n    const { chunkSize } = config.rumApi; // 512 KB chunk size\n    const deflate = new pako.Deflate();\n    const totalChunks = Math.ceil(fileContent.length / chunkSize);\n\n    for (let i = 0; i < totalChunks; i++) {\n      const start = i * chunkSize;\n      const end = start + chunkSize;\n      const chunk = fileContent.subarray(start, end);\n\n      const isLastChunk = i === totalChunks - 1;\n\n      deflate.push(chunk, isLastChunk);\n    }\n\n    const { err, msg, result } = deflate;\n\n    if (err) console.error(RED_COLOR, msg);\n\n    return result;\n  }\n\n  private static async getFileMetadata(filePath: string): Promise<FileMetadata> {\n    const { size } = await stat(filePath);\n    const { name } = path.parse(filePath);\n    const content = await readFile(filePath);\n\n    return { chunkName: name, size, content };\n  }\n}\n"]}

package/dist/utils/shared.utils.d.ts

@@ -0,0 +1,9 @@
+import { UploadBlobRequest } from '../proto-models/com/coralogix/blobset/v2/blobset_service';
+export declare function createUploadBlobRequestChunks(request: UploadBlobRequest): AsyncGenerator<{
+    data: Uint8Array;
+    entityType: import("../proto-models/com/coralogix/blobset/v2/entity_type").EntityType;
+    entityMetadata: import("../proto-models/com/coralogix/blobset/v2/entity_metadata").EntityMetadata | undefined;
+}, void, unknown>;
+export declare const consoleError: (message: any) => void;
+export declare const checkMissingArguments: <T>(options: T, requiredArgs: (keyof T)[]) => void;
+export declare const validateCompressedFilesSize: (compressedFilesSize: number, maxCompressedFilesSize: number) => void;

package/dist/utils/shared.utils.js

@@ -0,0 +1,62 @@
+"use strict";
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCompressedFilesSize = exports.checkMissingArguments = exports.consoleError = exports.createUploadBlobRequestChunks = void 0;
+const consts_1 = require("../consts/consts");
+function createUploadBlobRequestChunks(request) {
+    return __asyncGenerator(this, arguments, function* createUploadBlobRequestChunks_1() {
+        const { data } = request;
+        if (!data)
+            return yield __await(void 0);
+        for (let i = 0; i < data.length; i += consts_1.STREAM_CHUNK_SIZE) {
+            yield yield __await(Object.assign(Object.assign({}, request), { data: data.subarray(i, i + consts_1.STREAM_CHUNK_SIZE) }));
+        }
+    });
+}
+exports.createUploadBlobRequestChunks = createUploadBlobRequestChunks;
+const consoleError = (message) => {
+    console.log(consts_1.RED_COLOR, '❌ An error occurred');
+    console.error(consts_1.RED_COLOR, message);
+};
+exports.consoleError = consoleError;
+const checkMissingArguments = (options, requiredArgs) => {
+    const missingArgs = [];
+    requiredArgs.forEach((arg) => {
+        if (!options[arg])
+            missingArgs.push(arg);
+    });
+    if (missingArgs.length > 0) {
+        const missingArgsList = missingArgs.map(arg => `- ${arg}`).join('\n');
+        const errorMessage = `❌ Missing required arguments:\n${missingArgsList}\nPlease provide the necessary options`;
+        console.error(consts_1.RED_COLOR, errorMessage);
+        process.exit(1);
+    }
+};
+exports.checkMissingArguments = checkMissingArguments;
+const validateCompressedFilesSize = (compressedFilesSize, maxCompressedFilesSize) => {
+    if (compressedFilesSize > maxCompressedFilesSize) {
+        // Convert sizes to megabytes (MB)
+        const compressedFilesSizeMB = (compressedFilesSize / consts_1.MB).toFixed(2);
+        const maxCompressedFilesSizeMB = (maxCompressedFilesSize / consts_1.MB).toFixed(2);
+        const errorMessage = `
+            ❌ Error: The total size of compressed files exceeds the maximum allowed size.
+            Total Compressed Files Size: ${compressedFilesSizeMB} MB
+            Maximum Allowed Size: ${maxCompressedFilesSizeMB} MB
+            `;
+        console.error(consts_1.RED_COLOR, errorMessage);
+        process.exit(1);
+    }
+};
+exports.validateCompressedFilesSize = validateCompressedFilesSize;
+//# sourceMappingURL=data:application/json;base64,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

package/models/dsym-commands.model.ts

@@ -0,0 +1,11 @@
+export interface UploadDsymCommandOptions {
+  privateKey: string;
+  application: string;
+  version: string;
+  folderPath: string;
+  commitHash?: string;
+  repoName?: string;
+  orgName?: string;
+  env: string;
+  help?: string;
+}

package/models/react-native-commands.model.ts

@@ -0,0 +1,11 @@
+export interface UploadReactNativeSourceMapsCommandOptions {
+  privateKey: string;
+  application: string;
+  version: string;
+  folderPath: string;
+  commitHash?: string;
+  repoName?: string;
+  orgName?: string;
+  env: string;
+  help?: string;
+}

package/models/{commands.model.ts → source-maps-commands.model.ts}

@@ -1,4 +1,4 @@
-export interface DeleteCommandOptions {
+export interface DeleteSourceMapsCommandOptions {
   privateKey: string;
   application: string;
   version: string;
@@ -6,7 +6,7 @@ export interface DeleteCommandOptions {
   help?: string;
 }
 
-export interface UpdateCommandOptions {
+export interface UpdateSourceMapsCommandOptions {
   privateKey: string;
   application: string;
   version: string;
@@ -19,7 +19,7 @@ export interface UpdateCommandOptions {
   help?: string;
 }
 
-export interface UploadCommandOptions {
+export interface UploadSourceMapsCommandOptions {
   privateKey: string;
   application: string;
   version: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@coralogix/rum-cli",
-  "version": "1.1.21",
-  "description": "corlogix rum cli",
+  "version": "1.1.24",
+  "description": "coralogix rum cli",
   "bin": {
     "coralogix-rum-cli": "dist/cli/rum-cli.js"
   },
@@ -26,7 +26,8 @@
     "pako": "^2.1.0",
     "prom-client": "^14.0.1",
     "protobufjs": "^7.2.4",
-    "@grpc/grpc-js": "1.8.0"
+    "@grpc/grpc-js": "1.8.0",
+    "zlib": "^1.0.5"
   },
   "devDependencies": {
     "@types/bunyan": "^1.8.8",