@coralogix/rum-cli 1.1.21 → 1.1.24

package/dist/api/dsym.api.d.ts

@@ -0,0 +1,4 @@
+import { UploadBlobRequest } from '../proto-models/com/coralogix/blobset/v2/blobset_service';
+export declare class DsymApi {
+    static uploadDsym(uploadBlobRequest: UploadBlobRequest, application: string, version: string, repoName: string | undefined, commitHash: string | undefined, orgName: string | undefined, env: string, privateKey: string): Promise<void>;
+}

package/dist/api/dsym.api.js

@@ -0,0 +1,50 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DsymApi = void 0;
+const nice_grpc_1 = require("nice-grpc");
+const config_1 = __importDefault(require("../config/config"));
+const shared_utils_1 = require("../utils/shared.utils");
+const release_entity_type_1 = require("../proto-models/com/coralogix/rum/v2/release_entity_type");
+const client_factory_1 = require("./client/client-factory");
+const request_builder_1 = require("./client/request-builder");
+class DsymApi {
+    static uploadDsym(uploadBlobRequest, application, version, repoName, commitHash, orgName, env, privateKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const blobSetClient = client_factory_1.ClientFactory.getBlobSetGrpcClient(env);
+                const rumSourceMapClient = client_factory_1.ClientFactory.getRumSourceMapGrpcClient(env);
+                const metadata = new nice_grpc_1.Metadata();
+                metadata.set('Authorization', `Bearer ${privateKey}`);
+                (0, shared_utils_1.validateCompressedFilesSize)(uploadBlobRequest.data.length, config_1.default.rumApi.reactNativeMaxCompressedFilesSize);
+                const { exists } = yield rumSourceMapClient.isEntityReleaseExists({ releaseId: version, application, releaseEntityType: release_entity_type_1.ReleaseEntityType.RELEASE_ENTITY_TYPE_DSYM }, { metadata });
+                if (exists) {
+                    (0, shared_utils_1.consoleError)(`Entity release already exists for releaseId: ${version} and application: ${application}`);
+                    return;
+                }
+                const updatedUploadBlobRequest = request_builder_1.RequestBuilder.createDsymUploadBlobRequest(uploadBlobRequest, application, version, repoName, commitHash, orgName);
+                const iterableRequest = (0, shared_utils_1.createUploadBlobRequestChunks)(updatedUploadBlobRequest);
+                yield blobSetClient.uploadBlob(iterableRequest, { metadata });
+                const uploadEntityReleaseRequest = request_builder_1.RequestBuilder.createDsymReleaseRequest(application, version, repoName, commitHash, orgName);
+                yield rumSourceMapClient.createEntityRelease(uploadEntityReleaseRequest, { metadata });
+            }
+            catch (error) {
+                (0, shared_utils_1.consoleError)(`Failed to upload dSYMs: ${error}`);
+                throw error;
+            }
+        });
+    }
+}
+exports.DsymApi = DsymApi;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/api/react-native.api.d.ts

@@ -0,0 +1,4 @@
+import { UploadBlobRequest } from '../proto-models/com/coralogix/blobset/v2/blobset_service';
+export declare class ReactNativeApi {
+    static uploadReactNativeSourceMaps(uploadBlobRequest: UploadBlobRequest, application: string, version: string, repoName: string | undefined, commitHash: string | undefined, orgName: string | undefined, env: string, privateKey: string): Promise<void>;
+}

package/dist/api/react-native.api.js

@@ -0,0 +1,50 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReactNativeApi = void 0;
+const nice_grpc_1 = require("nice-grpc");
+const config_1 = __importDefault(require("../config/config"));
+const shared_utils_1 = require("../utils/shared.utils");
+const release_entity_type_1 = require("../proto-models/com/coralogix/rum/v2/release_entity_type");
+const client_factory_1 = require("./client/client-factory");
+const request_builder_1 = require("./client/request-builder");
+class ReactNativeApi {
+    static uploadReactNativeSourceMaps(uploadBlobRequest, application, version, repoName, commitHash, orgName, env, privateKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const blobSetClient = client_factory_1.ClientFactory.getBlobSetGrpcClient(env);
+                const rumSourceMapClient = client_factory_1.ClientFactory.getRumSourceMapGrpcClient(env);
+                const metadata = new nice_grpc_1.Metadata();
+                metadata.set('Authorization', `Bearer ${privateKey}`);
+                (0, shared_utils_1.validateCompressedFilesSize)(uploadBlobRequest.data.length, config_1.default.rumApi.dsymMaxCompressedFilesSize);
+                const { exists } = yield rumSourceMapClient.isEntityReleaseExists({ releaseId: version, application, releaseEntityType: release_entity_type_1.ReleaseEntityType.RELEASE_ENTITY_TYPE_REACT_NATIVE }, { metadata });
+                if (exists) {
+                    (0, shared_utils_1.consoleError)(`Entity release already exists for releaseId: ${version} and application: ${application}`);
+                    return;
+                }
+                const updatedUploadBlobRequest = request_builder_1.RequestBuilder.createReactNativeUploadBlobRequest(uploadBlobRequest, application, version, repoName, commitHash, orgName);
+                const iterableRequest = (0, shared_utils_1.createUploadBlobRequestChunks)(updatedUploadBlobRequest);
+                yield blobSetClient.uploadBlob(iterableRequest, { metadata });
+                const uploadEntityReleaseRequest = request_builder_1.RequestBuilder.createReactNativeReleaseRequest(application, version, repoName, commitHash, orgName);
+                yield rumSourceMapClient.createEntityRelease(uploadEntityReleaseRequest, { metadata });
+            }
+            catch (error) {
+                (0, shared_utils_1.consoleError)(`Failed to upload react native source maps: ${error}`);
+                throw error;
+            }
+        });
+    }
+}
+exports.ReactNativeApi = ReactNativeApi;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/api/{rum-api.d.ts → source-maps.api.d.ts}

@@ -1,6 +1,6 @@
 import { DeleteSourceMapRequest, UpdateSourceMapRequest, UploadSourceMapsRequest } from '../proto-models/com/coralogix/rum/v2/rum_source_map_service';
-export declare class RumApi {
-    private static getGrpcClient;
+export declare class SourceMapsApi {
+    private static sumFilesSize;
     static uploadSourceMaps(request: UploadSourceMapsRequest, env: string, privateKey: string): Promise<void>;
     static updateSourceMap(request: UpdateSourceMapRequest, env: string, privateKey: string): Promise<void>;
     static deleteSourceMap(request: DeleteSourceMapRequest, env: string, privateKey: string): Promise<void>;

package/dist/api/source-maps.api.js

@@ -0,0 +1,97 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceMapsApi = void 0;
+const nice_grpc_1 = require("nice-grpc");
+const config_1 = __importDefault(require("../config/config"));
+const shared_utils_1 = require("../utils/shared.utils");
+const client_factory_1 = require("./client/client-factory");
+const file_processor_utils_1 = require("../utils/file-processor.utils");
+class SourceMapsApi {
+    static sumFilesSize(files) {
+        return files.reduce((acc, file) => acc + file.size, 0);
+    }
+    static uploadSourceMaps(request, env, privateKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const client = client_factory_1.ClientFactory.getRumSourceMapGrpcClient(env);
+                const { files, releaseId, application, repoName, commitHash, user } = request;
+                const compressedFiles = yield Promise.all(files.map((file) => __awaiter(this, void 0, void 0, function* () {
+                    const content = file_processor_utils_1.FileProcessor.compressFileContentChunks(file.content);
+                    const size = content.length;
+                    const chunkName = file.chunkName;
+                    return { chunkName, size, content };
+                })));
+                (0, shared_utils_1.validateCompressedFilesSize)(this.sumFilesSize(compressedFiles), config_1.default.rumApi.sourceMapsMaxCompressedFilesSize);
+                const metadata = new nice_grpc_1.Metadata();
+                metadata.set('Authorization', `Bearer ${privateKey}`);
+                yield client.uploadSourceMaps({
+                    files: compressedFiles,
+                    releaseId,
+                    application,
+                    repoName,
+                    commitHash,
+                    user,
+                }, { metadata });
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    static updateSourceMap(request, env, privateKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const client = client_factory_1.ClientFactory.getRumSourceMapGrpcClient(env);
+                const { files, releaseId, application, repoName, commitHash, user, generate } = request;
+                const compressedFiles = yield Promise.all(files.map((file) => __awaiter(this, void 0, void 0, function* () {
+                    const content = file_processor_utils_1.FileProcessor.compressFileContentChunks(file.content);
+                    const size = content.length;
+                    const chunkName = file.chunkName;
+                    return { chunkName, size, content };
+                })));
+                (0, shared_utils_1.validateCompressedFilesSize)(this.sumFilesSize(compressedFiles), config_1.default.rumApi.sourceMapsMaxCompressedFilesSize);
+                const metadata = new nice_grpc_1.Metadata();
+                metadata.set('Authorization', `Bearer ${privateKey}`);
+                yield client.updateSourceMap({
+                    files: compressedFiles,
+                    releaseId,
+                    application,
+                    repoName,
+                    commitHash,
+                    user,
+                    generate: (generate === null || generate === void 0 ? void 0 : generate.toString()) || undefined,
+                }, { metadata });
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    static deleteSourceMap(request, env, privateKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const client = client_factory_1.ClientFactory.getRumSourceMapGrpcClient(env);
+                const metadata = new nice_grpc_1.Metadata();
+                metadata.set('Authorization', `Bearer ${privateKey}`);
+                yield client.deleteSourceMap(request, { metadata });
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+}
+exports.SourceMapsApi = SourceMapsApi;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"source-maps.api.js","sourceRoot":"","sources":["../../api/source-maps.api.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,yCAA6C;AAC7C,8DAAsC;AAQtC,wDAAoE;AACpE,4DAAwD;AACxD,wEAA8D;AAE9D,MAAa,aAAa;IAChB,MAAM,CAAC,YAAY,CAAC,KAAqB;QAC/C,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IACzD,CAAC;IAED,MAAM,CAAO,gBAAgB,CAAC,OAAgC,EAAE,GAAW,EAAE,UAAkB;;YAC7F,IAAI;gBACF,MAAM,MAAM,GAAiD,8BAAa,CAAC,yBAAyB,CAAC,GAAG,CAAC,CAAC;gBAE1G,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC;gBAE9E,MAAM,eAAe,GAAmB,MAAM,OAAO,CAAC,GAAG,CACvD,KAAK,CAAC,GAAG,CAAC,CAAO,IAAkB,EAAE,EAAE;oBACrC,MAAM,OAAO,GAAG,oCAAa,CAAC,yBAAyB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;oBACtE,MAAM,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC;oBAC5B,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;oBACjC,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;gBACtC,CAAC,CAAA,CAAC,CACH,CAAC;gBAEF,IAAA,0CAA2B,EAAC,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,EAAE,gBAAM,CAAC,MAAM,CAAC,gCAAgC,CAAC,CAAC;gBAEhH,MAAM,QAAQ,GAAG,IAAI,oBAAQ,EAAE,CAAC;gBAEhC,QAAQ,CAAC,GAAG,CAAC,eAAe,EAAE,UAAU,UAAU,EAAE,CAAC,CAAC;gBAEtD,MAAM,MAAM,CAAC,gBAAgB,CAC3B;oBACE,KAAK,EAAE,eAAe;oBACtB,SAAS;oBACT,WAAW;oBACX,QAAQ;oBACR,UAAU;oBACV,IAAI;iBACL,EACD,EAAE,QAAQ,EAAE,CACb,CAAC;aACH;YAAC,OAAO,KAAK,EAAE;gBACd,MAAM,KAAK,CAAC;aACb;QACH,CAAC;KAAA;IAED,MAAM,CAAO,eAAe,CAAC,OAA+B,EAAE,GAAW,EAAE,UAAkB;;YAC3F,IAAI;gBACF,MAAM,MAAM,GAAiD,8BAAa,CAAC,yBAAyB,CAAC,GAAG,CAAC,CAAC;gBAE1G,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC;gBAExF,MAAM,eAAe,GAAmB,MAAM,OAAO,CAAC,GAAG,CACvD,KAAK,CAAC,GAAG,CAAC,CAAO,IAAkB,EAAE,EAAE;oBACrC,MAAM,OAAO,GAAG,oCAAa,CAAC,yBAAyB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;oBACtE,MAAM,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC;oBAC5B,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;oBACjC,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;gBACtC,CAAC,CAAA,CAAC,CACH,CAAC;gBAEF,IAAA,0CAA2B,EAAC,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,EAAE,gBAAM,CAAC,MAAM,CAAC,gCAAgC,CAAC,CAAC;gBAEhH,MAAM,QAAQ,GAAG,IAAI,oBAAQ,EAAE,CAAC;gBAEhC,QAAQ,CAAC,GAAG,CAAC,eAAe,EAAE,UAAU,UAAU,EAAE,CAAC,CAAC;gBAEtD,MAAM,MAAM,CAAC,eAAe,CAC1B;oBACE,KAAK,EAAE,eAAe;oBACtB,SAAS;oBACT,WAAW;oBACX,QAAQ;oBACR,UAAU;oBACV,IAAI;oBACJ,QAAQ,EAAE,CAAA,QAAQ,aAAR,QAAQ,uBAAR,QAAQ,CAAE,QAAQ,EAAE,KAAI,SAAS;iBAC5C,EACD,EAAE,QAAQ,EAAE,CACb,CAAC;aACH;YAAC,OAAO,KAAK,EAAE;gBACd,MAAM,KAAK,CAAC;aACb;QACH,CAAC;KAAA;IAED,MAAM,CAAO,eAAe,CAAC,OAA+B,EAAE,GAAW,EAAE,UAAkB;;YAC3F,IAAI;gBACF,MAAM,MAAM,GAAiD,8BAAa,CAAC,yBAAyB,CAAC,GAAG,CAAC,CAAC;gBAE1G,MAAM,QAAQ,GAAG,IAAI,oBAAQ,EAAE,CAAC;gBAEhC,QAAQ,CAAC,GAAG,CAAC,eAAe,EAAE,UAAU,UAAU,EAAE,CAAC,CAAC;gBAEtD,MAAM,MAAM,CAAC,eAAe,CAAC,OAAO,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC;aACrD;YAAC,OAAO,KAAK,EAAE;gBACd,MAAM,KAAK,CAAC;aACb;QACH,CAAC;KAAA;CACF;AA7FD,sCA6FC","sourcesContent":["import { Client, Metadata } from 'nice-grpc';\nimport config from '../config/config';\nimport {\n  DeleteSourceMapRequest,\n  RumSourceMapServiceDefinition,\n  UpdateSourceMapRequest,\n  UploadSourceMapsRequest,\n} from '../proto-models/com/coralogix/rum/v2/rum_source_map_service';\nimport { FileMetadata } from '../proto-models/com/coralogix/rum/v2/file';\nimport { validateCompressedFilesSize } from '../utils/shared.utils';\nimport { ClientFactory } from './client/client-factory';\nimport { FileProcessor } from '../utils/file-processor.utils';\n\nexport class SourceMapsApi {\n  private static sumFilesSize(files: FileMetadata[]): number {\n    return files.reduce((acc, file) => acc + file.size, 0);\n  }\n\n  static async uploadSourceMaps(request: UploadSourceMapsRequest, env: string, privateKey: string) {\n    try {\n      const client: Client<typeof RumSourceMapServiceDefinition> = ClientFactory.getRumSourceMapGrpcClient(env);\n\n      const { files, releaseId, application, repoName, commitHash, user } = request;\n\n      const compressedFiles: FileMetadata[] = await Promise.all(\n        files.map(async (file: FileMetadata) => {\n          const content = FileProcessor.compressFileContentChunks(file.content);\n          const size = content.length;\n          const chunkName = file.chunkName;\n          return { chunkName, size, content };\n        }),\n      );\n\n      validateCompressedFilesSize(this.sumFilesSize(compressedFiles), config.rumApi.sourceMapsMaxCompressedFilesSize);\n\n      const metadata = new Metadata();\n\n      metadata.set('Authorization', `Bearer ${privateKey}`);\n\n      await client.uploadSourceMaps(\n        {\n          files: compressedFiles,\n          releaseId,\n          application,\n          repoName,\n          commitHash,\n          user,\n        },\n        { metadata },\n      );\n    } catch (error) {\n      throw error;\n    }\n  }\n\n  static async updateSourceMap(request: UpdateSourceMapRequest, env: string, privateKey: string) {\n    try {\n      const client: Client<typeof RumSourceMapServiceDefinition> = ClientFactory.getRumSourceMapGrpcClient(env);\n\n      const { files, releaseId, application, repoName, commitHash, user, generate } = request;\n\n      const compressedFiles: FileMetadata[] = await Promise.all(\n        files.map(async (file: FileMetadata) => {\n          const content = FileProcessor.compressFileContentChunks(file.content);\n          const size = content.length;\n          const chunkName = file.chunkName;\n          return { chunkName, size, content };\n        }),\n      );\n\n      validateCompressedFilesSize(this.sumFilesSize(compressedFiles), config.rumApi.sourceMapsMaxCompressedFilesSize);\n\n      const metadata = new Metadata();\n\n      metadata.set('Authorization', `Bearer ${privateKey}`);\n\n      await client.updateSourceMap(\n        {\n          files: compressedFiles,\n          releaseId,\n          application,\n          repoName,\n          commitHash,\n          user,\n          generate: generate?.toString() || undefined,\n        },\n        { metadata },\n      );\n    } catch (error) {\n      throw error;\n    }\n  }\n\n  static async deleteSourceMap(request: DeleteSourceMapRequest, env: string, privateKey: string) {\n    try {\n      const client: Client<typeof RumSourceMapServiceDefinition> = ClientFactory.getRumSourceMapGrpcClient(env);\n\n      const metadata = new Metadata();\n\n      metadata.set('Authorization', `Bearer ${privateKey}`);\n\n      await client.deleteSourceMap(request, { metadata });\n    } catch (error) {\n      throw error;\n    }\n  }\n}\n"]}

package/dist/cli/commands/dsym/index.d.ts

@@ -0,0 +1,4 @@
+declare const dsymCommands: {
+    uploadDsymCommand: () => import("commander").Command;
+};
+export default dsymCommands;

package/dist/cli/commands/dsym/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const upload_dsym_command_1 = require("./upload-dsym-command");
+const dsymCommands = { uploadDsymCommand: upload_dsym_command_1.uploadDsymCommand };
+exports.default = dsymCommands;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9jbGkvY29tbWFuZHMvZHN5bS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLCtEQUEwRDtBQUUxRCxNQUFNLFlBQVksR0FBRyxFQUFFLGlCQUFpQixFQUFqQix1Q0FBaUIsRUFBRSxDQUFDO0FBRTNDLGtCQUFlLFlBQVksQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHVwbG9hZERzeW1Db21tYW5kIH0gZnJvbSAnLi91cGxvYWQtZHN5bS1jb21tYW5kJztcblxuY29uc3QgZHN5bUNvbW1hbmRzID0geyB1cGxvYWREc3ltQ29tbWFuZCB9O1xuXG5leHBvcnQgZGVmYXVsdCBkc3ltQ29tbWFuZHM7XG4iXX0=

package/dist/cli/commands/dsym/upload-dsym-command.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const uploadDsymCommand: () => Command;

package/dist/cli/commands/dsym/upload-dsym-command.js

@@ -0,0 +1,45 @@
+"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.uploadDsymCommand = void 0;
+const commander_1 = require("commander");
+const validators_1 = require("../../validators");
+const shared_utils_1 = require("../../../utils/shared.utils");
+const dsym_service_1 = require("../../../services/dsym.service");
+const uploadDsymCommand = () => {
+    const uploadCommand = new commander_1.Command('upload-dsym')
+        .option('-k, --private-key <privateKey>', 'Private key to authenticate with the API')
+        .option('-a, --application <application>', 'Name of the application')
+        .option('-v, --version <version>', 'The application version - must match the version used by RUM sdk')
+        .option('-f, --folder-path <folderPath>', 'Path to the folder containing the dsym')
+        .option('-e, --env <env>', 'Your environment', validators_1.validateEnvironment)
+        .option('-c, --commit-hash <commitHash>', 'GitHub commit hash (optional)')
+        .option('-n, --repo-name <repoName>', 'GitHub Repository name (optional)')
+        .option('-o, --org-name <orgName>', 'GitHub user name (optional)')
+        .description('Upload Dsym')
+        .action((options) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            if (options.help) {
+                uploadCommand.outputHelp();
+                process.exit(0);
+            }
+            const { privateKey, application, version, folderPath, commitHash, repoName, orgName, env } = options;
+            (0, shared_utils_1.checkMissingArguments)(options, ['privateKey', 'application', 'version', 'folderPath', 'env']);
+            yield dsym_service_1.DsymService.upload(application, version, repoName, commitHash, orgName, folderPath, env, privateKey);
+        }
+        catch (error) {
+            (0, shared_utils_1.consoleError)(error);
+        }
+    }));
+    return uploadCommand;
+};
+exports.uploadDsymCommand = uploadDsymCommand;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cli/commands/react-native/index.d.ts

@@ -0,0 +1,4 @@
+declare const reactNativeCommands: {
+    uploadReactNativeSourceMapsCommand: () => import("commander").Command;
+};
+export default reactNativeCommands;

package/dist/cli/commands/react-native/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const upload_react_native_source_maps_command_1 = require("./upload-react-native-source-maps-command");
+const reactNativeCommands = { uploadReactNativeSourceMapsCommand: upload_react_native_source_maps_command_1.uploadReactNativeSourceMapsCommand };
+exports.default = reactNativeCommands;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9jbGkvY29tbWFuZHMvcmVhY3QtbmF0aXZlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEsdUdBQStGO0FBRS9GLE1BQU0sbUJBQW1CLEdBQUcsRUFBRSxrQ0FBa0MsRUFBbEMsNEVBQWtDLEVBQUUsQ0FBQztBQUVuRSxrQkFBZSxtQkFBbUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHVwbG9hZFJlYWN0TmF0aXZlU291cmNlTWFwc0NvbW1hbmQgfSBmcm9tICcuL3VwbG9hZC1yZWFjdC1uYXRpdmUtc291cmNlLW1hcHMtY29tbWFuZCc7XG5cbmNvbnN0IHJlYWN0TmF0aXZlQ29tbWFuZHMgPSB7IHVwbG9hZFJlYWN0TmF0aXZlU291cmNlTWFwc0NvbW1hbmQgfTtcblxuZXhwb3J0IGRlZmF1bHQgcmVhY3ROYXRpdmVDb21tYW5kcztcbiJdfQ==

package/dist/cli/commands/react-native/upload-react-native-source-maps-command.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const uploadReactNativeSourceMapsCommand: () => Command;

package/dist/cli/commands/react-native/upload-react-native-source-maps-command.js

@@ -0,0 +1,51 @@
+"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.uploadReactNativeSourceMapsCommand = void 0;
+const commander_1 = require("commander");
+const validators_1 = require("../../validators");
+const shared_utils_1 = require("../../../utils/shared.utils");
+const react_native_service_1 = require("../../../services/react-native.service");
+const uploadReactNativeSourceMapsCommand = () => {
+    const uploadCommand = new commander_1.Command('upload-react-native-source-maps')
+        .option('-k, --private-key <privateKey>', 'Private key to authenticate with the API')
+        .option('-a, --application <application>', 'Name of the application')
+        .option('-v, --version <version>', 'The application version - must match the version used by RUM sdk')
+        .option('-f, --folder-path <folderPath>', 'Path to the folder containing the react native source map')
+        .option('-e, --env <env>', 'Your environment', validators_1.validateEnvironment)
+        .option('-c, --commit-hash <commitHash>', 'GitHub commit hash (optional)')
+        .option('-n, --repo-name <repoName>', 'GitHub Repository name (optional)')
+        .option('-o, --org-name <orgName>', 'GitHub user name (optional)')
+        .description('Upload react native source maps')
+        .action((options) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            if (options.help) {
+                uploadCommand.outputHelp();
+                process.exit(0);
+            }
+            const { privateKey, application, version, folderPath, commitHash, repoName, orgName, env } = options;
+            (0, shared_utils_1.checkMissingArguments)(options, [
+                'privateKey',
+                'application',
+                'version',
+                'folderPath',
+                'env',
+            ]);
+            yield react_native_service_1.ReactNativeService.upload(application, version, repoName, commitHash, orgName, folderPath, env, privateKey);
+        }
+        catch (error) {
+            (0, shared_utils_1.consoleError)(error);
+        }
+    }));
+    return uploadCommand;
+};
+exports.uploadReactNativeSourceMapsCommand = uploadReactNativeSourceMapsCommand;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cli/commands/source-maps/delete-source-maps-command.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const deleteSourceMapsCommand: () => Command;

package/dist/cli/commands/source-maps/delete-source-maps-command.js

@@ -0,0 +1,41 @@
+"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.deleteSourceMapsCommand = void 0;
+const commander_1 = require("commander");
+const validators_1 = require("../../validators");
+const source_maps_service_1 = require("../../../services/source-maps.service");
+const shared_utils_1 = require("../../../utils/shared.utils");
+const deleteSourceMapsCommand = () => {
+    const deleteCommand = new commander_1.Command('delete-source-maps')
+        .option('-k, --private-key <privateKey>', 'Private key to authenticate with the API')
+        .option('-a, --application <application>', 'Name of the application')
+        .option('-v, --version <version>', 'The application version - must match the version used by RUM sdk')
+        .option('-e, --env <env>', 'Your environment', validators_1.validateEnvironment)
+        .description('Delete source maps')
+        .action((options) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            if (options.help) {
+                deleteCommand.outputHelp();
+                process.exit(0);
+            }
+            const { privateKey, application, version, env } = options;
+            (0, shared_utils_1.checkMissingArguments)(options, ['privateKey', 'application', 'version', 'env']);
+            yield source_maps_service_1.SourceMapsService.delete(application, version, env, privateKey);
+        }
+        catch (error) {
+            (0, shared_utils_1.consoleError)(error);
+        }
+    }));
+    return deleteCommand;
+};
+exports.deleteSourceMapsCommand = deleteSourceMapsCommand;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cli/commands/source-maps/index.d.ts

@@ -0,0 +1,6 @@
+declare const sourceMapsCommands: {
+    uploadSourceMapsCommand: () => import("commander").Command;
+    updateSourceMapsCommand: () => import("commander").Command;
+    deleteSourceMapsCommand: () => import("commander").Command;
+};
+export default sourceMapsCommands;

package/dist/cli/commands/source-maps/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const update_source_maps_command_1 = require("./update-source-maps-command");
+const upload_source_maps_command_1 = require("./upload-source-maps-command");
+const delete_source_maps_command_1 = require("./delete-source-maps-command");
+const sourceMapsCommands = { uploadSourceMapsCommand: upload_source_maps_command_1.uploadSourceMapsCommand, updateSourceMapsCommand: update_source_maps_command_1.updateSourceMapsCommand, deleteSourceMapsCommand: delete_source_maps_command_1.deleteSourceMapsCommand };
+exports.default = sourceMapsCommands;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9jbGkvY29tbWFuZHMvc291cmNlLW1hcHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSw2RUFBdUU7QUFDdkUsNkVBQXVFO0FBQ3ZFLDZFQUF1RTtBQUV2RSxNQUFNLGtCQUFrQixHQUFHLEVBQUUsdUJBQXVCLEVBQXZCLG9EQUF1QixFQUFFLHVCQUF1QixFQUF2QixvREFBdUIsRUFBRSx1QkFBdUIsRUFBdkIsb0RBQXVCLEVBQUUsQ0FBQztBQUV6RyxrQkFBZSxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHVwZGF0ZVNvdXJjZU1hcHNDb21tYW5kIH0gZnJvbSAnLi91cGRhdGUtc291cmNlLW1hcHMtY29tbWFuZCc7XG5pbXBvcnQgeyB1cGxvYWRTb3VyY2VNYXBzQ29tbWFuZCB9IGZyb20gJy4vdXBsb2FkLXNvdXJjZS1tYXBzLWNvbW1hbmQnO1xuaW1wb3J0IHsgZGVsZXRlU291cmNlTWFwc0NvbW1hbmQgfSBmcm9tICcuL2RlbGV0ZS1zb3VyY2UtbWFwcy1jb21tYW5kJztcblxuY29uc3Qgc291cmNlTWFwc0NvbW1hbmRzID0geyB1cGxvYWRTb3VyY2VNYXBzQ29tbWFuZCwgdXBkYXRlU291cmNlTWFwc0NvbW1hbmQsIGRlbGV0ZVNvdXJjZU1hcHNDb21tYW5kIH07XG5cbmV4cG9ydCBkZWZhdWx0IHNvdXJjZU1hcHNDb21tYW5kcztcbiJdfQ==

package/dist/cli/commands/source-maps/update-source-maps-command.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const updateSourceMapsCommand: () => Command;

package/dist/cli/commands/source-maps/update-source-maps-command.js

@@ -0,0 +1,46 @@
+"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.updateSourceMapsCommand = void 0;
+const commander_1 = require("commander");
+const validators_1 = require("../../validators");
+const source_maps_service_1 = require("../../../services/source-maps.service");
+const shared_utils_1 = require("../../../utils/shared.utils");
+const updateSourceMapsCommand = () => {
+    const updateCommand = new commander_1.Command('update-source-maps')
+        .option('-k, --private-key <privateKey>', 'Private key to authenticate with the API')
+        .option('-a, --application <application>', 'Name of the application')
+        .option('-v, --version <version>', 'The application version - must match the version used by RUM sdk')
+        .option('-f, --folder-path <folderPath>', 'Path to the folder containing the source maps')
+        .option('-e, --env <env>', 'Your environment', validators_1.validateEnvironment)
+        .option('-c, --commit-hash <commitHash>', 'GitHub commit hash (optional)')
+        .option('-n, --repo-name <repoName>', 'GitHub Repository name (optional)')
+        .option('-o, --org-name <orgName>', 'GitHub user name (optional)')
+        .option('-g, --generate [generate]', 'Update existing release or create a new one if not found (optional)')
+        .description('Update source maps')
+        .action((options) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            if (options.help) {
+                updateCommand.outputHelp();
+                process.exit(0);
+            }
+            const { privateKey, application, version, folderPath, commitHash, repoName, orgName, env, generate } = options;
+            (0, shared_utils_1.checkMissingArguments)(options, ['privateKey', 'application', 'version', 'folderPath', 'env']);
+            yield source_maps_service_1.SourceMapsService.update(application, version, repoName, commitHash, orgName, folderPath, generate, env, privateKey);
+        }
+        catch (error) {
+            (0, shared_utils_1.consoleError)(error);
+        }
+    }));
+    return updateCommand;
+};
+exports.updateSourceMapsCommand = updateSourceMapsCommand;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlLXNvdXJjZS1tYXBzLWNvbW1hbmQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9jbGkvY29tbWFuZHMvc291cmNlLW1hcHMvdXBkYXRlLXNvdXJjZS1tYXBzLWNvbW1hbmQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7O0FBQUEseUNBQW9DO0FBQ3BDLGlEQUF1RDtBQUN2RCwrRUFBMEU7QUFDMUUsOERBQWtGO0FBRzNFLE1BQU0sdUJBQXVCLEdBQUcsR0FBRyxFQUFFO0lBQzFDLE1BQU0sYUFBYSxHQUFHLElBQUksbUJBQU8sQ0FBQyxvQkFBb0IsQ0FBQztTQUNwRCxNQUFNLENBQUMsZ0NBQWdDLEVBQUUsMENBQTBDLENBQUM7U0FDcEYsTUFBTSxDQUFDLGlDQUFpQyxFQUFFLHlCQUF5QixDQUFDO1NBQ3BFLE1BQU0sQ0FBQyx5QkFBeUIsRUFBRSxrRUFBa0UsQ0FBQztTQUNyRyxNQUFNLENBQUMsZ0NBQWdDLEVBQUUsK0NBQStDLENBQUM7U0FDekYsTUFBTSxDQUFDLGlCQUFpQixFQUFFLGtCQUFrQixFQUFFLGdDQUFtQixDQUFDO1NBQ2xFLE1BQU0sQ0FBQyxnQ0FBZ0MsRUFBRSwrQkFBK0IsQ0FBQztTQUN6RSxNQUFNLENBQUMsNEJBQTRCLEVBQUUsbUNBQW1DLENBQUM7U0FDekUsTUFBTSxDQUFDLDBCQUEwQixFQUFFLDZCQUE2QixDQUFDO1NBQ2pFLE1BQU0sQ0FBQywyQkFBMkIsRUFBRSxxRUFBcUUsQ0FBQztTQUMxRyxXQUFXLENBQUMsb0JBQW9CLENBQUM7U0FDakMsTUFBTSxDQUFDLENBQU8sT0FBdUMsRUFBRSxFQUFFO1FBQ3hELElBQUk7WUFDRixJQUFJLE9BQU8sQ0FBQyxJQUFJLEVBQUU7Z0JBQ2hCLGFBQWEsQ0FBQyxVQUFVLEVBQUUsQ0FBQztnQkFDM0IsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQzthQUNqQjtZQUVELE1BQU0sRUFBRSxVQUFVLEVBQUUsV0FBVyxFQUFFLE9BQU8sRUFBRSxVQUFVLEVBQUUsVUFBVSxFQUFFLFFBQVEsRUFBRSxPQUFPLEVBQUUsR0FBRyxFQUFFLFFBQVEsRUFBRSxHQUFHLE9BQU8sQ0FBQztZQUUvRyxJQUFBLG9DQUFxQixFQUFpQyxPQUFPLEVBQUUsQ0FBQyxZQUFZLEVBQUUsYUFBYSxFQUFFLFNBQVMsRUFBRSxZQUFZLEVBQUUsS0FBSyxDQUFDLENBQUMsQ0FBQztZQUU5SCxNQUFNLHVDQUFpQixDQUFDLE1BQU0sQ0FBQyxXQUFXLEVBQUUsT0FBTyxFQUFFLFFBQVEsRUFBRSxVQUFVLEVBQUUsT0FBTyxFQUFFLFVBQVUsRUFBRSxRQUFRLEVBQUUsR0FBRyxFQUFFLFVBQVUsQ0FBQyxDQUFDO1NBQzVIO1FBQUMsT0FBTyxLQUFLLEVBQUU7WUFDZCxJQUFBLDJCQUFZLEVBQUMsS0FBSyxDQUFDLENBQUM7U0FDckI7SUFDSCxDQUFDLENBQUEsQ0FBQyxDQUFDO0lBRUwsT0FBTyxhQUFhLENBQUM7QUFDdkIsQ0FBQyxDQUFDO0FBOUJXLFFBQUEsdUJBQXVCLDJCQThCbEMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21tYW5kIH0gZnJvbSAnY29tbWFuZGVyJztcbmltcG9ydCB7IHZhbGlkYXRlRW52aXJvbm1lbnQgfSBmcm9tICcuLi8uLi92YWxpZGF0b3JzJztcbmltcG9ydCB7IFNvdXJjZU1hcHNTZXJ2aWNlIH0gZnJvbSAnLi4vLi4vLi4vc2VydmljZXMvc291cmNlLW1hcHMuc2VydmljZSc7XG5pbXBvcnQgeyBjaGVja01pc3NpbmdBcmd1bWVudHMsIGNvbnNvbGVFcnJvciB9IGZyb20gJy4uLy4uLy4uL3V0aWxzL3NoYXJlZC51dGlscyc7XG5pbXBvcnQgeyBVcGRhdGVTb3VyY2VNYXBzQ29tbWFuZE9wdGlvbnMgfSBmcm9tICcuLi8uLi8uLi9tb2RlbHMvc291cmNlLW1hcHMtY29tbWFuZHMubW9kZWwnO1xuXG5leHBvcnQgY29uc3QgdXBkYXRlU291cmNlTWFwc0NvbW1hbmQgPSAoKSA9PiB7XG4gIGNvbnN0IHVwZGF0ZUNvbW1hbmQgPSBuZXcgQ29tbWFuZCgndXBkYXRlLXNvdXJjZS1tYXBzJylcbiAgICAub3B0aW9uKCctaywgLS1wcml2YXRlLWtleSA8cHJpdmF0ZUtleT4nLCAnUHJpdmF0ZSBrZXkgdG8gYXV0aGVudGljYXRlIHdpdGggdGhlIEFQSScpXG4gICAgLm9wdGlvbignLWEsIC0tYXBwbGljYXRpb24gPGFwcGxpY2F0aW9uPicsICdOYW1lIG9mIHRoZSBhcHBsaWNhdGlvbicpXG4gICAgLm9wdGlvbignLXYsIC0tdmVyc2lvbiA8dmVyc2lvbj4nLCAnVGhlIGFwcGxpY2F0aW9uIHZlcnNpb24gLSBtdXN0IG1hdGNoIHRoZSB2ZXJzaW9uIHVzZWQgYnkgUlVNIHNkaycpXG4gICAgLm9wdGlvbignLWYsIC0tZm9sZGVyLXBhdGggPGZvbGRlclBhdGg+JywgJ1BhdGggdG8gdGhlIGZvbGRlciBjb250YWluaW5nIHRoZSBzb3VyY2UgbWFwcycpXG4gICAgLm9wdGlvbignLWUsIC0tZW52IDxlbnY+JywgJ1lvdXIgZW52aXJvbm1lbnQnLCB2YWxpZGF0ZUVudmlyb25tZW50KVxuICAgIC5vcHRpb24oJy1jLCAtLWNvbW1pdC1oYXNoIDxjb21taXRIYXNoPicsICdHaXRIdWIgY29tbWl0IGhhc2ggKG9wdGlvbmFsKScpXG4gICAgLm9wdGlvbignLW4sIC0tcmVwby1uYW1lIDxyZXBvTmFtZT4nLCAnR2l0SHViIFJlcG9zaXRvcnkgbmFtZSAob3B0aW9uYWwpJylcbiAgICAub3B0aW9uKCctbywgLS1vcmctbmFtZSA8b3JnTmFtZT4nLCAnR2l0SHViIHVzZXIgbmFtZSAob3B0aW9uYWwpJylcbiAgICAub3B0aW9uKCctZywgLS1nZW5lcmF0ZSBbZ2VuZXJhdGVdJywgJ1VwZGF0ZSBleGlzdGluZyByZWxlYXNlIG9yIGNyZWF0ZSBhIG5ldyBvbmUgaWYgbm90IGZvdW5kIChvcHRpb25hbCknKVxuICAgIC5kZXNjcmlwdGlvbignVXBkYXRlIHNvdXJjZSBtYXBzJylcbiAgICAuYWN0aW9uKGFzeW5jIChvcHRpb25zOiBVcGRhdGVTb3VyY2VNYXBzQ29tbWFuZE9wdGlvbnMpID0+IHtcbiAgICAgIHRyeSB7XG4gICAgICAgIGlmIChvcHRpb25zLmhlbHApIHtcbiAgICAgICAgICB1cGRhdGVDb21tYW5kLm91dHB1dEhlbHAoKTtcbiAgICAgICAgICBwcm9jZXNzLmV4aXQoMCk7XG4gICAgICAgIH1cblxuICAgICAgICBjb25zdCB7IHByaXZhdGVLZXksIGFwcGxpY2F0aW9uLCB2ZXJzaW9uLCBmb2xkZXJQYXRoLCBjb21taXRIYXNoLCByZXBvTmFtZSwgb3JnTmFtZSwgZW52LCBnZW5lcmF0ZSB9ID0gb3B0aW9ucztcblxuICAgICAgICBjaGVja01pc3NpbmdBcmd1bWVudHM8VXBkYXRlU291cmNlTWFwc0NvbW1hbmRPcHRpb25zPihvcHRpb25zLCBbJ3ByaXZhdGVLZXknLCAnYXBwbGljYXRpb24nLCAndmVyc2lvbicsICdmb2xkZXJQYXRoJywgJ2VudiddKTtcblxuICAgICAgICBhd2FpdCBTb3VyY2VNYXBzU2VydmljZS51cGRhdGUoYXBwbGljYXRpb24sIHZlcnNpb24sIHJlcG9OYW1lLCBjb21taXRIYXNoLCBvcmdOYW1lLCBmb2xkZXJQYXRoLCBnZW5lcmF0ZSwgZW52LCBwcml2YXRlS2V5KTtcbiAgICAgIH0gY2F0Y2ggKGVycm9yKSB7XG4gICAgICAgIGNvbnNvbGVFcnJvcihlcnJvcik7XG4gICAgICB9XG4gICAgfSk7XG5cbiAgcmV0dXJuIHVwZGF0ZUNvbW1hbmQ7XG59O1xuIl19

package/dist/cli/commands/source-maps/upload-source-maps-command.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const uploadSourceMapsCommand: () => Command;

package/dist/cli/commands/source-maps/upload-source-maps-command.js

@@ -0,0 +1,45 @@
+"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.uploadSourceMapsCommand = void 0;
+const commander_1 = require("commander");
+const validators_1 = require("../../validators");
+const source_maps_service_1 = require("../../../services/source-maps.service");
+const shared_utils_1 = require("../../../utils/shared.utils");
+const uploadSourceMapsCommand = () => {
+    const uploadCommand = new commander_1.Command('upload-source-maps')
+        .option('-k, --private-key <privateKey>', 'Private key to authenticate with the API')
+        .option('-a, --application <application>', 'Name of the application')
+        .option('-v, --version <version>', 'The application version - must match the version used by RUM sdk')
+        .option('-f, --folder-path <folderPath>', 'Path to the folder containing the source maps')
+        .option('-e, --env <env>', 'Your environment', validators_1.validateEnvironment)
+        .option('-c, --commit-hash <commitHash>', 'GitHub commit hash (optional)')
+        .option('-n, --repo-name <repoName>', 'GitHub Repository name (optional)')
+        .option('-o, --org-name <orgName>', 'GitHub user name (optional)')
+        .description('Update source maps')
+        .action((options) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            if (options.help) {
+                uploadCommand.outputHelp();
+                process.exit(0);
+            }
+            const { privateKey, application, version, folderPath, commitHash, repoName, orgName, env } = options;
+            (0, shared_utils_1.checkMissingArguments)(options, ['privateKey', 'application', 'version', 'folderPath', 'env']);
+            yield source_maps_service_1.SourceMapsService.upload(application, version, repoName, commitHash, orgName, folderPath, env, privateKey);
+        }
+        catch (error) {
+            (0, shared_utils_1.consoleError)(error);
+        }
+    }));
+    return uploadCommand;
+};
+exports.uploadSourceMapsCommand = uploadSourceMapsCommand;
+//# sourceMappingURL=data:application/json;base64,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