@coralogix/rum-cli 1.1.21 → 1.1.24

package/protos/com/coralogix/rum/v2/rum_source_map_service.proto

@@ -2,6 +2,8 @@ syntax = "proto3";
 package com.coralogix.rum.v2;
 
 import "com/coralogix/rum/v2/file.proto";
+import "com/coralogix/rum/v2/release_entity_metadata.proto";
+import "com/coralogix/rum/v2/release_entity_type.proto";
 
 message UploadSourceMapsRequest {
   string application = 1;
@@ -28,12 +30,29 @@ message DeleteSourceMapRequest {
   string release_id = 2;
 }
 
+message CreateEntityReleaseRequest {
+  ReleaseEntityType release_entity_type = 2;
+  ReleaseEntityMetadata release_entity_metadata = 3;
+}
+
+message IsEntityReleaseExistsRequest {
+  string application = 1;
+  string release_id = 2;
+  ReleaseEntityType release_entity_type = 3;
+}
+
 message UploadSourceMapsResponse {}
 message UpdateSourceMapResponse {}
 message DeleteSourceMapResponse {}
+message CreateEntityReleaseResponse {}
+message IsEntityReleaseExistsResponse {
+  bool exists = 1;
+}
 
 service RumSourceMapService {
   rpc UploadSourceMaps(UploadSourceMapsRequest) returns (UploadSourceMapsResponse) {}
   rpc UpdateSourceMap(UpdateSourceMapRequest) returns (UpdateSourceMapResponse) {}
   rpc DeleteSourceMap(DeleteSourceMapRequest) returns (DeleteSourceMapResponse) {}
-}
+  rpc CreateEntityRelease(CreateEntityReleaseRequest) returns (CreateEntityReleaseResponse) {}
+  rpc IsEntityReleaseExists(IsEntityReleaseExistsRequest) returns (IsEntityReleaseExistsResponse) {}
+}

package/protos/com/coralogix/rum/v2/saved_filter.proto

@@ -0,0 +1,28 @@
+syntax = "proto3";
+package com.coralogix.rum.v2;
+
+message SavedFilterBasicProperties {
+  string name = 1;
+  string id = 2;
+  Page page = 3;
+}
+
+message SavedFilter {
+  SavedFilterBasicProperties saved_filter = 1;
+  bool is_favorite = 2;
+  optional string favorite_id = 3;
+  SavedFilterPermission permission = 4;
+}
+
+enum Page {
+  PAGE_UNSPECIFIED = 0;
+  PAGE_ERROR_TRACKING = 1;
+  PAGE_USER_SESSION = 2;
+  PAGE_WEB_VITALS = 3;
+}
+
+enum SavedFilterPermission {
+  SAVED_FILTER_PERMISSION_UNSPECIFIED = 0;
+  SAVED_FILTER_PERMISSION_PRIVATE = 1;
+  SAVED_FILTER_PERMISSION_PUBLIC = 2;
+}

package/protos/com/coralogix/rum/v2/snooze_errors.proto

@@ -0,0 +1,55 @@
+syntax = "proto3";
+package com.coralogix.rum.v2;
+
+enum SnoozeType {
+  SNOOZE_TYPE_UNSPECIFIED = 0;
+  SNOOZE_TYPE_TEMPLATE_ID = 1;
+  SNOOZE_TYPE_CATEGORY   = 2;
+}
+
+enum SnoozeCondition {
+  SNOOZE_CONDITION_UNSPECIFIED = 0;
+  SNOOZE_CONDITION_TIME = 1;
+}
+
+enum SnoozeStatus {
+  SNOOZE_STATUS_UNSPECIFIED = 0;
+  SNOOZE_STATUS_ACTIVE  = 1;
+  SNOOZE_STATUS_EXPIRING_SOON  = 2;
+  SNOOZE_STATUS_UPDATED = 3;
+}
+
+message Category {
+  string key = 1;
+  repeated string values = 2;
+}
+
+message Categories {
+  repeated Category categories = 1;
+}
+
+message TimeCondition {
+  int64 end_time = 1;
+}
+
+message TimeBasedSnooze {
+  oneof snooze_details {
+  Categories categories = 1;
+  string template = 2;
+}
+  int64 end_time = 3;
+}
+
+message Management {
+  SnoozeType snooze_type = 1;
+  SnoozeCondition snooze_condition = 2;
+  SnoozeStatus snooze_status = 3;
+  int64 initial_time = 4;
+  int64 expires_time = 5;
+  oneof snooze_details {
+    string template = 6;
+    Categories categories = 7;
+  }
+  string id = 8;
+}
+

package/protos/com/coralogix/rum/v2/template.proto

@@ -31,4 +31,10 @@ message TemplateResult {
   Template template = 1;
   int64 number_of_errors = 2;
   int64 number_of_users = 3;
+}
+
+message TemplateDate {
+  string template_id = 1;
+  int64 created_at = 2;
+  int64 updated_at = 3;
 }

package/services/dsym.service.ts

@@ -0,0 +1,33 @@
+import { GRAY_COLOR, GREEN_COLOR } from '../consts/consts';
+import { consoleError } from '../utils/shared.utils';
+import { UploadBlobRequest } from '../proto-models/com/coralogix/blobset/v2/blobset_service';
+import { DsymApi } from '../api/dsym.api';
+import { FileProcessor } from '../utils/file-processor.utils';
+
+export class DsymService {
+  static async upload(
+    application: string,
+    version: string,
+    repoName: string | undefined,
+    commitHash: string | undefined,
+    orgName: string | undefined,
+    folderPath: string,
+    env: string,
+    privateKey: string,
+  ): Promise<void> {
+    const request = UploadBlobRequest.create();
+
+    console.log(GRAY_COLOR, '🚀 Uploading Dsym...');
+
+    try {
+      await FileProcessor.traverseDsymFolder(folderPath, request);
+
+      await DsymApi.uploadDsym(request, application, version, repoName, commitHash, orgName, env, privateKey);
+
+      console.log(GREEN_COLOR, '✅ Dsym uploaded successfully!');
+      console.log(GREEN_COLOR, '✅ Processing complete.');
+    } catch (error) {
+      consoleError(error);
+    }
+  }
+}

package/services/react-native.service.ts

@@ -0,0 +1,34 @@
+import { GRAY_COLOR, GREEN_COLOR } from '../consts/consts';
+import { consoleError } from '../utils/shared.utils';
+import { ReactNativeApi } from '../api/react-native.api';
+import { UploadBlobRequest } from '../proto-models/com/coralogix/blobset/v2/blobset_service';
+import { FileProcessor } from '../utils/file-processor.utils';
+
+export class ReactNativeService {
+  static async upload(
+    application: string,
+    version: string,
+    repoName: string | undefined,
+    commitHash: string | undefined,
+    orgName: string | undefined,
+    folderPath: string,
+    env: string,
+    privateKey: string,
+  ): Promise<void> {
+    const request = UploadBlobRequest.create();
+
+    console.log(GRAY_COLOR, '🚀 Uploading react native source map...');
+
+    try {
+      const totalFiles: number | undefined = await FileProcessor.traverseSourceMapsFolder(folderPath, '.map', request);
+
+      await ReactNativeApi.uploadReactNativeSourceMaps(request, application, version, repoName, commitHash, orgName, env, privateKey);
+
+      console.log(GREEN_COLOR, '✅ React native source map uploaded successfully!');
+      console.log(GREEN_COLOR, `✅ Total files processed: ${totalFiles || 0}`);
+      console.log(GREEN_COLOR, '✅ Processing complete.');
+    } catch (error) {
+      consoleError(error);
+    }
+  }
+}

package/services/source-maps.service.ts

@@ -3,9 +3,10 @@ import {
   UpdateSourceMapRequest,
   UploadSourceMapsRequest,
 } from '../proto-models/com/coralogix/rum/v2/rum_source_map_service';
-import { RumApi } from '../api/rum-api';
-import { GRAY_COLOR, GREEN_COLOR, RED_COLOR } from '../consts/consts';
-import { traverseFolder } from '../utils';
+import { SourceMapsApi } from '../api/source-maps.api';
+import { GRAY_COLOR, GREEN_COLOR } from '../consts/consts';
+import { consoleError } from '../utils/shared.utils';
+import { FileProcessor } from '../utils/file-processor.utils';
 
 export class SourceMapsService {
   static async upload(
@@ -29,16 +30,15 @@ export class SourceMapsService {
     console.log(GRAY_COLOR, '🚀 Uploading source maps...');
 
     try {
-      await traverseFolder(folderPath, request);
+      await FileProcessor.traverseSourceMapsFolderOld(folderPath, request);
 
-      await RumApi.uploadSourceMaps(request, env, privateKey);
+      await SourceMapsApi.uploadSourceMaps(request, env, privateKey);
 
       console.log(GREEN_COLOR, '✅ Source maps uploaded successfully!');
       console.log(GREEN_COLOR, `✅ Total chunk files processed: ${request.files.length}`);
       console.log(GREEN_COLOR, '✅ Processing complete.');
     } catch (error) {
-      console.log(RED_COLOR, '❌ An error occurred');
-      console.error(RED_COLOR, error);
+      consoleError(error);
     }
   }
 
@@ -65,16 +65,15 @@ export class SourceMapsService {
     console.log(GRAY_COLOR, '🔄 Updating source maps...');
 
     try {
-      await traverseFolder(folderPath, request);
+      await FileProcessor.traverseSourceMapsFolderOld(folderPath, request);
 
-      await RumApi.updateSourceMap(request, env, privateKey);
+      await SourceMapsApi.updateSourceMap(request, env, privateKey);
 
       console.log(GREEN_COLOR, '✅ Source maps updated successfully!');
       console.log(GREEN_COLOR, `✅ Total chunk files processed: ${request.files.length}`);
       console.log(GREEN_COLOR, '✅ Processing complete.');
     } catch (error) {
-      console.log(RED_COLOR, '❌ An error occurred');
-      console.error(RED_COLOR, error);
+      consoleError(error);
     }
   }
 
@@ -87,12 +86,11 @@ export class SourceMapsService {
     console.log(GRAY_COLOR, '🗑️ Deleting source maps...');
 
     try {
-      await RumApi.deleteSourceMap(request, env, privateKey);
+      await SourceMapsApi.deleteSourceMap(request, env, privateKey);
 
       console.log(GREEN_COLOR, '✅ Source maps deleted successfully!');
     } catch (error) {
-      console.log(RED_COLOR, '❌ An error occurred');
-      console.error(RED_COLOR, error);
+      consoleError(error);
     }
   }
 }

package/utils/file-processor.utils.ts

@@ -0,0 +1,176 @@
+import * as fs from 'fs';
+import { Dirent, promises as fsPromises } from 'fs';
+import * as path from 'path';
+import zlib from 'zlib';
+import { consoleError } from './shared.utils';
+import { UploadBlobRequest } from '../proto-models/com/coralogix/blobset/v2/blobset_service';
+import { UploadSourceMapsRequest } from '../proto-models/com/coralogix/rum/v2/rum_source_map_service';
+import config from '../config';
+import pako from 'pako';
+import { FileMetadata } from '../proto-models/com/coralogix/rum/v2/file';
+import { RED_COLOR } from '../consts/consts';
+
+const { readdir, stat, readFile } = fsPromises;
+
+export class FileProcessor {
+  static async traverseDsymFolder(folderPath: string, request: UploadBlobRequest): Promise<void> {
+    try {
+      const processDsymFolder = async (dsymFolderPath: string) => {
+        const dwarfPath = await FileProcessor.getDwarfPath(dsymFolderPath);
+        const content = await readFile(dwarfPath);
+        const compressedContent = zlib.gzipSync(content);
+        request.data = new Uint8Array(compressedContent);
+      };
+
+      // Check if the folder itself is a .dSYM folder
+      if (folderPath.endsWith('.dSYM')) {
+        await processDsymFolder(folderPath);
+        return;
+      }
+
+      const files: Dirent[] = await 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: string = path.join(folderPath, file.name);
+
+        if (file.isDirectory()) {
+          if (file.name.endsWith('.dSYM')) {
+            await processDsymFolder(filePath);
+            return;
+          } else {
+            await FileProcessor.traverseDsymFolder(filePath, request);
+          }
+        }
+      }
+    } catch (error) {
+      consoleError(`Error traversing directory: ${JSON.stringify(error)}`);
+    }
+  }
+
+  static async traverseSourceMapsFolder(
+    folderPath: string,
+    fileExtension: string,
+    request: UploadBlobRequest,
+  ): Promise<number | undefined> {
+    try {
+      const stats = await stat(folderPath);
+
+      if (stats.isFile() && folderPath.endsWith(fileExtension)) {
+        return await this.processSourceMapSingleFile(folderPath, fileExtension, request);
+      } else if (stats.isDirectory()) {
+        return await this.processSourceMapDirectory(folderPath, fileExtension, request);
+      }
+    } catch (error) {
+      consoleError(`Error traversing directory: ${error}`);
+    }
+  }
+
+  private static async processSourceMapSingleFile(filePath: string, fileExtension: string, request: UploadBlobRequest): Promise<number> {
+    try {
+      const content = await readFile(filePath);
+
+      const { name } = path.parse(filePath);
+
+      const fileData = { name, content: content.toString('base64') };
+
+      const compressedContent = zlib.gzipSync(Buffer.from(JSON.stringify([fileData])));
+
+      request.data = new Uint8Array(compressedContent);
+
+      return 1;
+    } catch (error) {
+      consoleError(`Error processing file: ${error}`);
+      throw error;
+    }
+  }
+
+  private static async processSourceMapDirectory(folderPath: string, fileExtension: string, request: UploadBlobRequest): Promise<number> {
+    const files = await readdir(folderPath, { withFileTypes: true });
+    const fileDataList: { name: string; content: string }[] = [];
+
+    for (const dirent of files) {
+      const filePath = path.join(folderPath, dirent.name);
+
+      if (dirent.isFile() && dirent.name.endsWith(fileExtension)) {
+        const content = await readFile(filePath);
+        const { name } = path.parse(filePath);
+        fileDataList.push({ name, content: content.toString('base64') });
+      } else if (dirent.isDirectory()) {
+        await this.traverseSourceMapsFolder(filePath, fileExtension, request);
+      }
+    }
+
+    const compressedContent = zlib.gzipSync(Buffer.from(JSON.stringify(fileDataList)));
+
+    request.data = new Uint8Array(compressedContent);
+
+    return fileDataList.length;
+  }
+
+  private static async getDwarfPath(dsymPath: string): Promise<string> {
+    const dwarfPath: string = 'Contents/Resources/DWARF';
+    const targetPath: string = path.join(dsymPath, dwarfPath);
+    const files = fs.readdirSync(targetPath);
+    if (files.length === 1) {
+      return path.join(dsymPath, dwarfPath, files[0]);
+    } else {
+      consoleError(`Expected exactly one file in the directory, but found: ${files.length}`);
+      return '';
+    }
+  }
+
+  static async traverseSourceMapsFolderOld(folderPath: string, request: UploadSourceMapsRequest): Promise<void> {
+    const stack: string[] = [folderPath];
+
+    while (stack.length) {
+      const currentPath = stack.pop();
+      const entries: Dirent[] = await readdir(currentPath!, { withFileTypes: true });
+
+      await Promise.all(
+        entries.map(async (file: Dirent) => {
+          const { name } = file;
+          const entryPath = path.join(currentPath as string, name);
+          const isCorrectSuffix = file.isFile() && name.endsWith('.js.map');
+
+          if (file.isDirectory()) stack.push(entryPath);
+          else if (isCorrectSuffix) request.files.push(await FileProcessor.getFileMetadata(entryPath));
+        }),
+      );
+    }
+  }
+
+  static compressFileContentChunks(fileContent: Uint8Array): Uint8Array {
+    const { chunkSize } = config.rumApi; // 512 KB chunk size
+    const deflate = new pako.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(RED_COLOR, msg);
+
+    return result;
+  }
+
+  private static async getFileMetadata(filePath: string): Promise<FileMetadata> {
+    const { size } = await stat(filePath);
+    const { name } = path.parse(filePath);
+    const content = await readFile(filePath);
+
+    return { chunkName: name, size, content };
+  }
+}

package/utils/shared.utils.ts

@@ -0,0 +1,52 @@
+import { MB, RED_COLOR, STREAM_CHUNK_SIZE } from '../consts/consts';
+import { UploadBlobRequest } from '../proto-models/com/coralogix/blobset/v2/blobset_service';
+
+export async function* createUploadBlobRequestChunks(request: UploadBlobRequest) {
+  const { data } = request;
+
+  if (!data) return;
+
+  for (let i = 0; i < data.length; i += STREAM_CHUNK_SIZE) {
+    yield {
+      ...request,
+      data: data.subarray(i, i + STREAM_CHUNK_SIZE),
+    };
+  }
+}
+
+export const consoleError = (message: any): void => {
+  console.log(RED_COLOR, '❌ An error occurred');
+  console.error(RED_COLOR, message);
+};
+
+export const checkMissingArguments = <T>(options: T, requiredArgs: (keyof T)[]): void => {
+  const missingArgs: string[] = [];
+
+  requiredArgs.forEach((arg: keyof T) => {
+    if (!options[arg]) missingArgs.push(arg as string);
+  });
+
+  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(RED_COLOR, errorMessage);
+    process.exit(1);
+  }
+};
+
+export const validateCompressedFilesSize = (compressedFilesSize: number, maxCompressedFilesSize: number): void => {
+  if (compressedFilesSize > maxCompressedFilesSize) {
+    // Convert sizes to megabytes (MB)
+    const compressedFilesSizeMB: string = (compressedFilesSize / MB).toFixed(2);
+    const maxCompressedFilesSizeMB: string = (maxCompressedFilesSize / 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(RED_COLOR, errorMessage);
+    process.exit(1);
+  }
+};

package/cli/commands/index.ts

@@ -1,7 +0,0 @@
-import { updateCommand } from './update-source-maps-command';
-import { uploadCommand } from './upload-source-maps-command';
-import { deleteCommand } from './delete-source-maps-command';
-
-const commands = { uploadCommand, updateCommand, deleteCommand };
-
-export default commands;

package/dist/api/rum-api.js

@@ -1,104 +0,0 @@
-"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.RumApi = void 0;
-const nice_grpc_1 = require("nice-grpc");
-const config_1 = __importDefault(require("../config/config"));
-const rum_source_map_service_1 = require("../proto-models/com/coralogix/rum/v2/rum_source_map_service");
-const utils_1 = require("../utils");
-const consts_1 = require("../consts/consts");
-class RumApi {
-    static getGrpcClient(env) {
-        const { maxMessageSize, keepaliveTimeMs, keepaliveTimeoutMs } = config_1.default.rumApi;
-        const channel = (0, nice_grpc_1.createChannel)(consts_1.envToDomain[env], undefined, {
-            'grpc.max_receive_message_length': maxMessageSize,
-            'grpc.max_send_message_length': maxMessageSize,
-            'grpc.keepalive_time_ms': keepaliveTimeMs,
-            'grpc.keepalive_timeout_ms': keepaliveTimeoutMs,
-        });
-        return (0, nice_grpc_1.createClient)(rum_source_map_service_1.RumSourceMapServiceDefinition, channel);
-    }
-    static uploadSourceMaps(request, env, privateKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const client = this.getGrpcClient(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 = (0, utils_1.compressFileContentChunks)(file.content);
-                    const size = content.length;
-                    const chunkName = file.chunkName;
-                    return { chunkName, size, content };
-                })));
-                (0, utils_1.validateCompressedFilesSize)(compressedFiles, config_1.default.rumApi.maxCompressedFilesSize);
-                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 = this.getGrpcClient(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 = (0, utils_1.compressFileContentChunks)(file.content);
-                    const size = content.length;
-                    const chunkName = file.chunkName;
-                    return { chunkName, size, content };
-                })));
-                (0, utils_1.validateCompressedFilesSize)(compressedFiles, config_1.default.rumApi.maxCompressedFilesSize);
-                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 = this.getGrpcClient(env);
-                const metadata = new nice_grpc_1.Metadata();
-                metadata.set('Authorization', `Bearer ${privateKey}`);
-                yield client.deleteSourceMap(request, { metadata });
-            }
-            catch (error) {
-                throw error;
-            }
-        });
-    }
-}
-exports.RumApi = RumApi;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rum-api.js","sourceRoot":"","sources":["../../api/rum-api.ts"],"names":[],"mappings":"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","sourcesContent":["import { Client, createChannel, createClient, 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 { compressFileContentChunks, validateCompressedFilesSize } from '../utils';\nimport { envToDomain } from '../consts/consts';\nimport { FileMetadata } from '../proto-models/com/coralogix/rum/v2/file';\n\nexport class RumApi {\n  private static getGrpcClient(env: string) {\n    const { maxMessageSize, keepaliveTimeMs, keepaliveTimeoutMs } = config.rumApi;\n\n    const channel = createChannel(envToDomain[env], undefined, {\n      'grpc.max_receive_message_length': maxMessageSize,\n      'grpc.max_send_message_length': maxMessageSize,\n      'grpc.keepalive_time_ms': keepaliveTimeMs,\n      'grpc.keepalive_timeout_ms': keepaliveTimeoutMs,\n    });\n\n    return createClient(RumSourceMapServiceDefinition, channel);\n  }\n\n  static async uploadSourceMaps(request: UploadSourceMapsRequest, env: string, privateKey: string) {\n    try {\n      const client: Client<typeof RumSourceMapServiceDefinition> = this.getGrpcClient(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 = compressFileContentChunks(file.content);\n          const size = content.length;\n          const chunkName = file.chunkName;\n          return { chunkName, size, content };\n        }),\n      );\n\n      validateCompressedFilesSize(compressedFiles, config.rumApi.maxCompressedFilesSize);\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> = this.getGrpcClient(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 = compressFileContentChunks(file.content);\n          const size = content.length;\n          const chunkName = file.chunkName;\n          return { chunkName, size, content };\n        }),\n      );\n\n      validateCompressedFilesSize(compressedFiles, config.rumApi.maxCompressedFilesSize);\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> = this.getGrpcClient(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/delete-source-maps-command.d.ts

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