@coralogix/rum-cli 1.1.17 → 1.1.19

package/.prettierrc

@@ -0,0 +1,15 @@
+{
+  "printWidth": 140,
+  "tabWidth": 2,
+  "useTabs": false,
+  "semi": true,
+  "singleQuote": true,
+  "quoteProps": "preserve",
+  "trailingComma": "all",
+  "bracketSpacing": true,
+  "arrowParens": "avoid",
+  "requirePragma": false,
+  "insertPragma": false,
+  "proseWrap": "preserve",
+  "endOfLine": "lf"
+}

package/README.md

@@ -18,20 +18,28 @@ To install the Coralogix RUM CLI, follow these steps:
 2. Run the following command to install the CLI globally: `npm install -g coralogix-rum-cli`
 3. Once the installation is complete, you can use the CLI by running the `coralogix-rum-cli` command in your terminal.
 
-# Examples
+
+## Commands
 
 Here are some examples of how to use the Coralogix RUM CLI:
 
-1. Upload source maps:
+1. Create source maps:
+
+    - `coralogix-rum-cli upload-source-maps -k <privateKey> -a <application> -v <version> -f <folderPath> -e <env> -c <commitHash> -n <repoName> -o <orgName>`
 
-- `coralogix-rum-cli upload-source-maps -k <privateKey> -a <application> -v <version> -f <folderPath> -e <env> -c <commitHash> -n <repoName> -o <orgName>`
+2. Delete source maps:
 
-2. Display help:
+    - `coralogix-rum-cli delete-source-maps -k <privateKey> -a <application> -v <version> -e <env>`
 
-- `coralogix-rum-cli upload-source-maps --help`
+3. Update source maps:
 
-# Upload source maps
+    - `coralogix-rum-cli update-source-maps -k <privateKey> -a <application> -v <version> -f <folderPath> -e <env> -c <commitHash> -n <repoName> -o <orgName>`
 
+4. Display help for upload command:
+
+    - `coralogix-rum-cli upload-source-maps --help`
+   
+    
 ## Options
 
 - `-k, --private-key <privateKey>`: Private key to authenticate with the Coralogix API.
@@ -44,6 +52,18 @@ Here are some examples of how to use the Coralogix RUM CLI:
 - `-o, --org-name <orgName>`: GitHub organization name (optional).
 - `-h, --help`: Display help.
 
+## Environments
+
+The Coralogix RUM CLI supports the following environments:
+
+- AP1
+- AP2
+- EU1
+- EU2
+- US1
+
+Please use the appropriate environment value when specifying the `-e, --env` option.
+
 ## Source maps folder size limit
 
 The source map folder size limit is 100MB in this project. Please ensure that it does not exceed this limit.
@@ -87,19 +107,6 @@ coralogix-rum-cli upload-source-maps -k "$PRIVATE_KEY" -a "$APPLICATION" -v "$VE
 | IMPORTANT: The $VERSION param must align with the content of the version field in your CoralogixRum.init() configuration in [Coralogix SDK for Browsers](https://www.npmjs.com/package/@coralogix/browser) |
 |------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 
-<br>
-
-## Available Environments
-
-The Coralogix RUM CLI supports the following environments:
-
-- AP1
-- AP2
-- EU1
-- EU2
-- US1
-
-Please use the appropriate environment value when specifying the `-e, --env` option.
 
 ## Optional GitHub Information
 

package/api/rum-api.ts

@@ -1,101 +1,114 @@
-import {Client, createChannel, createClient, Metadata} from 'nice-grpc';
-import {envToDomain} from "../model/cli.model";
-import * as pako from 'pako';
-import config from "../config/config";
-import {RED_COLOR} from "../cli/theme";
-import {FileMetadata} from "../proto-models/com/coralogix/rum/v2/file";
+import { Client, createChannel, createClient, Metadata } from 'nice-grpc';
+import config from '../config/config';
 import {
-    RumSourceMapServiceDefinition,
-    UploadSourceMapsRequest
-} from "../proto-models/com/coralogix/rum/v2/rum_source_map_service";
-import {MB} from "../cli/consts/consts";
+  DeleteSourceMapRequest,
+  RumSourceMapServiceDefinition,
+  UpdateSourceMapRequest,
+  UploadSourceMapsRequest,
+} from '../proto-models/com/coralogix/rum/v2/rum_source_map_service';
+import { compressFileContentChunks, validateCompressedFilesSize } from '../utils';
+import { envToDomain } from '../consts/consts';
+import { FileMetadata } from '../proto-models/com/coralogix/rum/v2/file';
 
 export class RumApi {
-    static async uploadSourceMaps(request: UploadSourceMapsRequest, env: string, privateKey: string) {
-
-        const {maxMessageSize, keepaliveTimeMs, keepaliveTimeoutMs, maxCompressedFilesSize} = config.rumApi;
-
-        try {
-            const channel = createChannel(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,
-            });
-
-            const client: Client<typeof RumSourceMapServiceDefinition> = createClient(RumSourceMapServiceDefinition, channel);
-
-            const {files, releaseId, application, repoName, commitHash, user} = request;
-
-            const compressedFiles: FileMetadata[] = await Promise.all(
-                files.map(async (file: FileMetadata) => {
-                    const compressedChunks = this.compressFileContentChunks(file.content);
-
-                    const size = compressedChunks.length;
-
-                    return {chunkName: file.chunkName, size, content: compressedChunks};
-                })
-            );
-
-            this.validateCompressedFilesSize(compressedFiles, maxCompressedFilesSize);
-
-            const metadata = new Metadata();
-
-            metadata.set('Authorization', `Bearer ${privateKey}`);
-
-            await client.uploadSourceMaps({
-                files: compressedFiles,
-                releaseId,
-                application,
-                repoName,
-                commitHash,
-                user
-            }, {metadata});
-
-        } catch (error) {
-            throw error;
-        }
-    };
-
-    private 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 getGrpcClient(env: string) {
+    const { maxMessageSize, keepaliveTimeMs, keepaliveTimeoutMs } = config.rumApi;
+
+    const channel = createChannel(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 createClient(RumSourceMapServiceDefinition, channel);
+  }
+
+  static async uploadSourceMaps(request: UploadSourceMapsRequest, env: string, privateKey: string) {
+    try {
+      const client: Client<typeof RumSourceMapServiceDefinition> = this.getGrpcClient(env);
+
+      const { files, releaseId, application, repoName, commitHash, user } = request;
+
+      const compressedFiles: FileMetadata[] = await Promise.all(
+        files.map(async (file: FileMetadata) => {
+          const content = compressFileContentChunks(file.content);
+          const size = content.length;
+          const chunkName = file.chunkName;
+          return { chunkName, size, content };
+        }),
+      );
+
+      validateCompressedFilesSize(compressedFiles, config.rumApi.maxCompressedFilesSize);
+
+      const metadata = new Metadata();
+
+      metadata.set('Authorization', `Bearer ${privateKey}`);
+
+      await client.uploadSourceMaps(
+        {
+          files: compressedFiles,
+          releaseId,
+          application,
+          repoName,
+          commitHash,
+          user,
+        },
+        { metadata },
+      );
+    } catch (error) {
+      throw error;
     }
+  }
+
+  static async updateSourceMap(request: UpdateSourceMapRequest, env: string, privateKey: string) {
+    try {
+      const client: Client<typeof RumSourceMapServiceDefinition> = this.getGrpcClient(env);
+
+      const { files, releaseId, application, repoName, commitHash, user } = request;
+
+      const compressedFiles: FileMetadata[] = await Promise.all(
+        files.map(async (file: FileMetadata) => {
+          const content = compressFileContentChunks(file.content);
+          const size = content.length;
+          const chunkName = file.chunkName;
+          return { chunkName, size, content };
+        }),
+      );
+
+      validateCompressedFilesSize(compressedFiles, config.rumApi.maxCompressedFilesSize);
+
+      const metadata = new Metadata();
+
+      metadata.set('Authorization', `Bearer ${privateKey}`);
+
+      await client.updateSourceMap(
+        {
+          files: compressedFiles,
+          releaseId,
+          application,
+          repoName,
+          commitHash,
+          user,
+        },
+        { metadata },
+      );
+    } catch (error) {
+      throw error;
+    }
+  }
 
-    private static validateCompressedFilesSize(compressedFiles: FileMetadata[], maxCompressedFilesSize: number): void {
-        const compressedFilesSize = compressedFiles.reduce((sum, file) => sum + file.content.length, 0);
+  static async deleteSourceMap(request: DeleteSourceMapRequest, env: string, privateKey: string) {
+    try {
+      const client: Client<typeof RumSourceMapServiceDefinition> = this.getGrpcClient(env);
 
-        if (compressedFilesSize > maxCompressedFilesSize) {
-            // Convert sizes to megabytes (MB)
-            const compressedFilesSizeMB: string = (compressedFilesSize / MB).toFixed(2);
-            const maxCompressedFilesSizeMB: string = (maxCompressedFilesSize / MB).toFixed(2);
+      const metadata = new Metadata();
 
-            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
-            `;
+      metadata.set('Authorization', `Bearer ${privateKey}`);
 
-            console.error(RED_COLOR, errorMessage);
-            process.exit(1);
-        }
+      await client.deleteSourceMap(request, { metadata });
+    } catch (error) {
+      throw error;
     }
+  }
 }
-

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

@@ -0,0 +1,34 @@
+import { Command } from 'commander';
+import { validateEnvironment } from '../validators';
+import { RED_COLOR } from '../../consts/consts';
+import { SourceMapsService } from '../../services/source-maps.service';
+import { checkMissingArguments } from '../../utils';
+import { DeleteCommandOptions } from '../../models/commands.model';
+
+export const deleteCommand = () => {
+  const deleteCommand = new 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', validateEnvironment)
+    .description('Delete source maps')
+    .action(async (options: DeleteCommandOptions) => {
+      try {
+        if (options.help) {
+          deleteCommand.outputHelp();
+          process.exit(0);
+        }
+
+        const { privateKey, application, version, env } = options;
+
+        checkMissingArguments<DeleteCommandOptions>(options, ['privateKey', 'application', 'version', 'env']);
+
+        await SourceMapsService.delete(application, version, env, privateKey);
+      } catch (error) {
+        console.error(RED_COLOR, '❌ An error occurred:');
+        console.error(RED_COLOR, error);
+      }
+    });
+
+  return deleteCommand;
+};

package/cli/commands/index.ts

@@ -0,0 +1,7 @@
+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/cli/commands/update-source-maps-command.ts

@@ -0,0 +1,38 @@
+import { Command } from 'commander';
+import { validateEnvironment } from '../validators';
+import { RED_COLOR } from '../../consts/consts';
+import { SourceMapsService } from '../../services/source-maps.service';
+import { checkMissingArguments } from '../../utils';
+import { UpdateCommandOptions } from '../../models/commands.model';
+
+export const updateCommand = () => {
+  const updateCommand = new 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', 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(async (options: UpdateCommandOptions) => {
+      try {
+        if (options.help) {
+          updateCommand.outputHelp();
+          process.exit(0);
+        }
+
+        const { privateKey, application, version, folderPath, commitHash, repoName, orgName, env } = options;
+
+        checkMissingArguments<UpdateCommandOptions>(options, ['privateKey', 'application', 'version', 'folderPath', 'env']);
+
+        await SourceMapsService.update(application, version, repoName, commitHash, orgName, folderPath, env, privateKey);
+      } catch (error) {
+        console.error(RED_COLOR, '❌ An error occurred:');
+        console.error(RED_COLOR, error);
+      }
+    });
+
+  return updateCommand;
+};

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

@@ -0,0 +1,38 @@
+import { Command } from 'commander';
+import { validateEnvironment } from '../validators';
+import { RED_COLOR } from '../../consts/consts';
+import { SourceMapsService } from '../../services/source-maps.service';
+import { checkMissingArguments } from '../../utils';
+import { UploadCommandOptions } from '../../models/commands.model';
+
+export const uploadCommand = () => {
+  const uploadCommand = new 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', 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(async (options: UploadCommandOptions) => {
+      try {
+        if (options.help) {
+          uploadCommand.outputHelp();
+          process.exit(0);
+        }
+
+        const { privateKey, application, version, folderPath, commitHash, repoName, orgName, env } = options;
+
+        checkMissingArguments<UploadCommandOptions>(options, ['privateKey', 'application', 'version', 'folderPath', 'env']);
+
+        await SourceMapsService.upload(application, version, repoName, commitHash, orgName, folderPath, env, privateKey);
+      } catch (error) {
+        console.error(RED_COLOR, '❌ An error occurred:');
+        console.error(RED_COLOR, error);
+      }
+    });
+
+  return uploadCommand;
+};

package/cli/rum-cli.ts

@@ -1,54 +1,20 @@
 #!/usr/bin/env node
-import {Command} from 'commander';
-import {SourceMapsService} from "../services/source-maps/source-maps.service";
-import {validateEnvironment} from "./validators";
-import {RED_COLOR} from "./theme";
+import { Command } from 'commander';
+import commands from './commands';
 
-const program = new Command();
+const program: Command = new Command();
 
-program.name('coralogix-rum-cli').description('cli for upload source maps')
+program.name('coralogix-rum-cli').description('CLI for upload, update, and delete source maps');
 
-const uploadCommand = program.command('upload-source-maps');
+// Create instances for each command
+const uploadCommand: Command = commands.uploadCommand();
+const updateCommand: Command = commands.updateCommand();
+const deleteCommand: Command = commands.deleteCommand();
 
-uploadCommand
-    .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', 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 source maps')
-    .action(async (options) => {
-        try {
-            if (options.help) {
-                program.outputHelp();
-                process.exit(0);
-            }
-
-            const {privateKey, application, version, folderPath, commitHash, repoName, orgName, env} = options;
-
-            const missingArgs = [];
-
-            if (!privateKey) missingArgs.push('private-key');
-            if (!application) missingArgs.push('application');
-            if (!version) missingArgs.push('version');
-            if (!folderPath) missingArgs.push('folder-path');
-            if (!env) missingArgs.push('env');
-
-            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);
-            }
-
-            await SourceMapsService.upload(application, version, repoName, commitHash, orgName, folderPath, env, privateKey)
-        } catch (error) {
-            console.error(RED_COLOR, '❌ An error occurred:');
-            console.error(RED_COLOR, error);
-        }
-    });
+// Register commands
+program.addCommand(uploadCommand);
+program.addCommand(updateCommand);
+program.addCommand(deleteCommand);
 
+// Parse command line arguments
 program.parse(process.argv);

package/cli/validators/index.ts

@@ -1,14 +1,13 @@
-import {envToDomain} from "../../model/cli.model";
-import {RED_COLOR} from "../theme";
+import { envToDomain, RED_COLOR } from '../../consts/consts';
 
 export const validateEnvironment = (env: string): string => {
-    const validEnvironments = Object.keys(envToDomain).join(', ');
+  const validEnvironments = Object.keys(envToDomain).join(', ');
 
-    if (!(env in envToDomain)) {
-        const errorMessage = `❌ Invalid environment: ${env}. Possible values are: ${validEnvironments}`;
-        console.error(RED_COLOR, errorMessage);
-        process.exit(1);
-    }
+  if (!(env in envToDomain)) {
+    const errorMessage = `❌ Invalid environment: ${env}. Possible values are: ${validEnvironments}`;
+    console.error(RED_COLOR, errorMessage);
+    process.exit(1);
+  }
 
-    return env;
-}
+  return env;
+};

package/config/config.ts

@@ -1,35 +1,35 @@
-import {KB, MB} from "../cli/consts/consts";
+import { MB } from '../consts/consts';
 
 export interface LoggerConfig {
-    maxLogSize: number;
-    logLevel: string;
+  maxLogSize: number;
+  logLevel: string;
 }
 
 export interface rumApiConfig {
-    maxMessageSize: number,
-    keepaliveTimeMs: number
-    keepaliveTimeoutMs: number
-    chunkSize: number,
-    maxCompressedFilesSize :number
+  maxMessageSize: number;
+  keepaliveTimeMs: number;
+  keepaliveTimeoutMs: number;
+  chunkSize: number;
+  maxCompressedFilesSize: number;
 }
 
 export interface Config {
-    logger: LoggerConfig;
-    rumApi: rumApiConfig;
+  logger: LoggerConfig;
+  rumApi: rumApiConfig;
 }
 
 const config: Config = {
-    logger: {
-        maxLogSize: 10000,
-        logLevel: 'debug',
-    },
-    rumApi: {
-        keepaliveTimeMs: 240000,
-        keepaliveTimeoutMs: 240000,
-        maxMessageSize: 200 * 1024 * 1024, // 200MB(in bytes)
-        maxCompressedFilesSize: 200 * 1024 * 1024, // 200MB (in bytes)
-        chunkSize: 1024 * 1024, // 1MB (in bytes)
-    }
+  logger: {
+    maxLogSize: 10000,
+    logLevel: 'debug',
+  },
+  rumApi: {
+    keepaliveTimeMs: 240000,
+    keepaliveTimeoutMs: 240000,
+    maxMessageSize: 200 * MB, // 200MB(in bytes)
+    maxCompressedFilesSize: 200 * MB, // 200MB (in bytes)
+    chunkSize: MB, // 1MB (in bytes)
+  },
 };
 
 export default config;

package/consts/consts.ts

@@ -0,0 +1,16 @@
+export const MB = 1024 * 1024;
+
+export const GREEN_COLOR = '\x1b[32m%s\x1b[0m';
+
+export const RED_COLOR = '\x1b[31m%s\x1b[0m';
+
+export const GRAY_COLOR = '\x1b[37m%s\x1b[0m';
+
+export const envToDomain: Record<string, string> = {
+  EU1: 'https://ng-api-grpc.coralogix.com:443', // eu-west-1 (Ireland)
+  EU2: 'https://ng-api-grpc.eu2.coralogix.com:443', // eu-north-1 (Stockholm)
+  US1: 'https://ng-api-grpc.coralogix.us:443', // us-east-2 (Ohio)
+  US2: 'https://ng-api-grpc.cx498.coralogix.com:443', // us-west-2 (Oregon)
+  AP1: 'https://ng-api-grpc.app.coralogix.in:443', // ap-south-1 (Mumbai)
+  AP2: 'https://ng-api-grpc.coralogixsg.com:443', // ap-southeast-1 (Singapore)
+};

package/dist/api/rum-api.d.ts

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