@coralogix/rum-cli 1.1.28 → 1.1.29

package/api/base/base.api.ts

@@ -0,0 +1,118 @@
+import { Client, Metadata } from 'nice-grpc';
+import { BlobSetServiceDefinition, UploadBlobRequest } from '../../proto-models/com/coralogix/blobset/v2/blobset_service';
+import { consoleError, createUploadBlobRequestChunks, validateCompressedFilesSize } from '../../utils/shared.utils';
+import { GrpcClientFactory } from '../../grpc-client/grpc-client-factory';
+import { CreateEntityReleaseRequest, RumSourceMapServiceDefinition } from '../../proto-models/com/coralogix/rum/v2/rum_source_map_service';
+import { EntityType } from '../../proto-models/com/coralogix/blobset/v2/entity_type';
+import { ReleaseEntityType } from '../../proto-models/com/coralogix/rum/v2/release_entity_type';
+import { EntityMetadata } from '../../proto-models/com/coralogix/blobset/v2/entity_metadata';
+import { ReleaseEntityMetadata } from '../../proto-models/com/coralogix/rum/v2/release_entity_metadata';
+
+export abstract class BaseApi {
+  protected abstract getEntityType(): EntityType;
+  protected abstract getReleaseEntityType(): ReleaseEntityType;
+  protected abstract getMaxCompressedFileSize(): number;
+  protected abstract buildReleaseEntityMetadata(
+    application: string,
+    version: string,
+    repoName?: string,
+    commitHash?: string,
+    orgName?: string,
+  ): ReleaseEntityMetadata;
+  protected abstract buildEntityMetadata(
+    application: string,
+    version: string,
+    repoName?: string,
+    commitHash?: string,
+    orgName?: string,
+  ): EntityMetadata;
+
+  private async uploadBlob(
+    blobSetClient: Client<typeof BlobSetServiceDefinition>,
+    request: UploadBlobRequest,
+    entityMetadata: EntityMetadata | undefined,
+    metadata: Metadata,
+  ): Promise<void> {
+    request.entityMetadata = entityMetadata;
+    request.entityType = this.getEntityType();
+
+    const iterableRequest = createUploadBlobRequestChunks(request);
+
+    await blobSetClient.uploadBlob(iterableRequest, { metadata });
+  }
+
+  private async createEntityRelease(
+    rumSourceMapClient: Client<typeof RumSourceMapServiceDefinition>,
+    releaseEntityMetadata: ReleaseEntityMetadata | undefined,
+    metadata: Metadata,
+  ): Promise<void> {
+    const request: CreateEntityReleaseRequest = {
+      releaseEntityType: this.getReleaseEntityType(),
+      releaseEntityMetadata,
+    };
+
+    await rumSourceMapClient.createEntityRelease(request, { metadata });
+  }
+
+  private createGrpcMetadata(privateKey: string): Metadata {
+    const metadata: Metadata = new Metadata();
+    metadata.set('Authorization', `Bearer ${privateKey}`);
+    return metadata;
+  }
+
+  private async checkEntityReleaseExists(
+    rumSourceMapClient: Client<typeof RumSourceMapServiceDefinition>,
+    application: string,
+    version: string,
+    metadata: Metadata,
+  ): Promise<boolean> {
+    const { exists } = await rumSourceMapClient.isEntityReleaseExists(
+      { releaseId: version, application, releaseEntityType: this.getReleaseEntityType() },
+      { metadata },
+    );
+    return exists;
+  }
+
+  public async upload(
+    request: UploadBlobRequest,
+    application: string,
+    version: string,
+    repoName: string | undefined,
+    commitHash: string | undefined,
+    orgName: string | undefined,
+    env: string,
+    privateKey: string,
+  ): Promise<void> {
+    const metadata: Metadata = this.createGrpcMetadata(privateKey);
+    const blobSetClient = GrpcClientFactory.getBlobSetGrpcClient(env, this.getMaxCompressedFileSize());
+    const rumSourceMapClient = GrpcClientFactory.getRumSourceMapGrpcClient(env, this.getMaxCompressedFileSize());
+
+    try {
+      validateCompressedFilesSize(request.data.length, this.getMaxCompressedFileSize());
+
+      const releaseExists: boolean = await this.checkEntityReleaseExists(rumSourceMapClient, application, version, metadata);
+
+      if (releaseExists) {
+        consoleError(`Entity release already exists for releaseId: ${version} and application: ${application}`);
+        return;
+      }
+
+      const releaseEntityMetadata: ReleaseEntityMetadata = this.buildReleaseEntityMetadata(
+        application,
+        version,
+        repoName,
+        commitHash,
+        orgName,
+      );
+
+      const entityMetadata: EntityMetadata = this.buildEntityMetadata(application, version, repoName, commitHash, orgName);
+
+      await this.uploadBlob(blobSetClient, request, entityMetadata, metadata);
+
+      await this.createEntityRelease(rumSourceMapClient, releaseEntityMetadata, metadata);
+    } catch (error) {
+      consoleError(`Failed to upload: ${error}`);
+      throw error;
+    }
+  }
+}

package/api/dsym/dsym.api.ts

@@ -0,0 +1,62 @@
+import { EntityType } from '../../proto-models/com/coralogix/blobset/v2/entity_type';
+import { ReleaseEntityType } from '../../proto-models/com/coralogix/rum/v2/release_entity_type';
+import config from '../../config/config';
+import { BaseApi } from '../base/base.api';
+import { ReleaseEntityMetadata } from '../../proto-models/com/coralogix/rum/v2/release_entity_metadata';
+import { EntityMetadata } from '../../proto-models/com/coralogix/blobset/v2/entity_metadata';
+
+export class DsymApi extends BaseApi {
+  protected getEntityType(): EntityType {
+    return EntityType.ENTITY_TYPE_DSYM;
+  }
+
+  protected getReleaseEntityType(): ReleaseEntityType {
+    return ReleaseEntityType.RELEASE_ENTITY_TYPE_DSYM;
+  }
+
+  protected getMaxCompressedFileSize(): number {
+    return config.rumApi.dsymMaxCompressedFilesSize;
+  }
+
+  protected buildReleaseEntityMetadata(
+    application: string,
+    version: string,
+    repoName?: string,
+    commitHash?: string,
+    orgName?: string,
+  ): ReleaseEntityMetadata {
+    return {
+      metadata: {
+        $case: 'dsymMetadata',
+        dsymMetadata: {
+          application,
+          releaseId: version,
+          repoName: repoName || '',
+          commitHash: commitHash || '',
+          orgName: orgName || '',
+        },
+      },
+    };
+  }
+
+  protected buildEntityMetadata(
+    application: string,
+    version: string,
+    repoName?: string,
+    commitHash?: string,
+    orgName?: string,
+  ): EntityMetadata {
+    return {
+      metadata: {
+        $case: 'dsymMetadata',
+        dsymMetadata: {
+          application,
+          releaseId: version,
+          repoName: repoName || '',
+          commitHash: commitHash || '',
+          orgName: orgName || '',
+        },
+      },
+    };
+  }
+}

package/api/proguard/proguard.api.ts

@@ -0,0 +1,62 @@
+import { EntityType } from '../../proto-models/com/coralogix/blobset/v2/entity_type';
+import { ReleaseEntityType } from '../../proto-models/com/coralogix/rum/v2/release_entity_type';
+import config from '../../config/config';
+import { BaseApi } from '../base/base.api';
+import { ReleaseEntityMetadata } from '../../proto-models/com/coralogix/rum/v2/release_entity_metadata';
+import { EntityMetadata } from '../../proto-models/com/coralogix/blobset/v2/entity_metadata';
+
+export class ProguardApi extends BaseApi {
+  protected getEntityType(): EntityType {
+    return EntityType.ENTITY_TYPE_PROGUARD;
+  }
+
+  protected getReleaseEntityType(): ReleaseEntityType {
+    return ReleaseEntityType.RELEASE_ENTITY_TYPE_PROGUARD;
+  }
+
+  protected getMaxCompressedFileSize(): number {
+    return config.rumApi.proguardMaxCompressedFilesSize;
+  }
+
+  protected buildReleaseEntityMetadata(
+    application: string,
+    version: string,
+    repoName?: string,
+    commitHash?: string,
+    orgName?: string,
+  ): ReleaseEntityMetadata {
+    return {
+      metadata: {
+        $case: 'proguardMetadata',
+        proguardMetadata: {
+          application,
+          releaseId: version,
+          repoName: repoName || '',
+          commitHash: commitHash || '',
+          orgName: orgName || '',
+        },
+      },
+    };
+  }
+
+  protected buildEntityMetadata(
+    application: string,
+    version: string,
+    repoName?: string,
+    commitHash?: string,
+    orgName?: string,
+  ): EntityMetadata {
+    return {
+      metadata: {
+        $case: 'proguardMetadata',
+        proguardMetadata: {
+          application,
+          releaseId: version,
+          repoName: repoName || '',
+          commitHash: commitHash || '',
+          orgName: orgName || '',
+        },
+      },
+    };
+  }
+}

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

@@ -0,0 +1,62 @@
+import { EntityType } from '../../proto-models/com/coralogix/blobset/v2/entity_type';
+import { ReleaseEntityType } from '../../proto-models/com/coralogix/rum/v2/release_entity_type';
+import config from '../../config/config';
+import { BaseApi } from '../base/base.api';
+import { ReleaseEntityMetadata } from '../../proto-models/com/coralogix/rum/v2/release_entity_metadata';
+import { EntityMetadata } from '../../proto-models/com/coralogix/blobset/v2/entity_metadata';
+
+export class ReactNativeApi extends BaseApi {
+  protected getEntityType(): EntityType {
+    return EntityType.ENTITY_TYPE_SOURCE_MAP;
+  }
+
+  protected getReleaseEntityType(): ReleaseEntityType {
+    return ReleaseEntityType.RELEASE_ENTITY_TYPE_REACT_NATIVE;
+  }
+
+  protected getMaxCompressedFileSize(): number {
+    return config.rumApi.reactNativeMaxCompressedFilesSize;
+  }
+
+  protected buildReleaseEntityMetadata(
+    application: string,
+    version: string,
+    repoName?: string,
+    commitHash?: string,
+    orgName?: string,
+  ): ReleaseEntityMetadata {
+    return {
+      metadata: {
+        $case: 'sourceMapMetadata',
+        sourceMapMetadata: {
+          application,
+          releaseId: version,
+          repoName: repoName || '',
+          commitHash: commitHash || '',
+          orgName: orgName || '',
+        },
+      },
+    };
+  }
+
+  protected buildEntityMetadata(
+    application: string,
+    version: string,
+    repoName?: string,
+    commitHash?: string,
+    orgName?: string,
+  ): EntityMetadata {
+    return {
+      metadata: {
+        $case: 'sourceMapMetadata',
+        sourceMapMetadata: {
+          application,
+          releaseId: version,
+          repoName: repoName || '',
+          commitHash: commitHash || '',
+          orgName: orgName || '',
+        },
+      },
+    };
+  }
+}

package/api/source-maps/source-maps.api.ts

@@ -0,0 +1,62 @@
+import { EntityType } from '../../proto-models/com/coralogix/blobset/v2/entity_type';
+import { ReleaseEntityType } from '../../proto-models/com/coralogix/rum/v2/release_entity_type';
+import config from '../../config/config';
+import { BaseApi } from '../base/base.api';
+import { ReleaseEntityMetadata } from '../../proto-models/com/coralogix/rum/v2/release_entity_metadata';
+import { EntityMetadata } from '../../proto-models/com/coralogix/blobset/v2/entity_metadata';
+
+export class SourceMapsApi extends BaseApi {
+  protected getEntityType(): EntityType {
+    return EntityType.ENTITY_TYPE_SOURCE_MAP;
+  }
+
+  protected getReleaseEntityType(): ReleaseEntityType {
+    return ReleaseEntityType.RELEASE_ENTITY_TYPE_SOURCE_MAP;
+  }
+
+  protected getMaxCompressedFileSize(): number {
+    return config.rumApi.sourceMapsMaxCompressedFilesSize;
+  }
+
+  protected buildReleaseEntityMetadata(
+    application: string,
+    version: string,
+    repoName?: string,
+    commitHash?: string,
+    orgName?: string,
+  ): ReleaseEntityMetadata {
+    return {
+      metadata: {
+        $case: 'sourceMapMetadata',
+        sourceMapMetadata: {
+          application,
+          releaseId: version,
+          repoName: repoName || '',
+          commitHash: commitHash || '',
+          orgName: orgName || '',
+        },
+      },
+    };
+  }
+
+  protected buildEntityMetadata(
+    application: string,
+    version: string,
+    repoName?: string,
+    commitHash?: string,
+    orgName?: string,
+  ): EntityMetadata {
+    return {
+      metadata: {
+        $case: 'sourceMapMetadata',
+        sourceMapMetadata: {
+          application,
+          releaseId: version,
+          repoName: repoName || '',
+          commitHash: commitHash || '',
+          orgName: orgName || '',
+        },
+      },
+    };
+  }
+}

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

@@ -1,7 +1,7 @@
 import { Command } from 'commander';
 import { validateEnvironment } from '../../validators';
 import { checkMissingArguments, consoleError } from '../../../utils/shared.utils';
-import { DsymService } from '../../../services/dsym.service';
+import { DsymService } from '../../../services/dsym/dsym.service';
 import { UploadDsymCommandOptions } from '../../../models/dsym-commands.model';
 
 export const uploadDsymCommand = () => {
@@ -26,7 +26,9 @@ export const uploadDsymCommand = () => {
 
         checkMissingArguments<UploadDsymCommandOptions>(options, ['privateKey', 'application', 'version', 'folderPath', 'env']);
 
-        await DsymService.upload(application, version, repoName, commitHash, orgName, folderPath, env, privateKey);
+        const service: DsymService = new DsymService();
+
+        await service.upload(application, version, repoName, commitHash, orgName, folderPath, env, privateKey);
       } catch (error) {
         consoleError(error);
       }

package/cli/commands/proguard/upload-proguard-command.ts

@@ -2,7 +2,7 @@ import { Command } from 'commander';
 import { validateEnvironment } from '../../validators';
 import { checkMissingArguments, consoleError } from '../../../utils/shared.utils';
 import { UploadProguardCommandOptions } from '../../../models/proguard-commands.model';
-import { ProguardService } from '../../../services/proguard.service';
+import { ProguardService } from '../../../services/proguard/proguard.service';
 
 export const uploadProguardCommand = () => {
   const uploadCommand = new Command('upload-proguard')
@@ -26,7 +26,9 @@ export const uploadProguardCommand = () => {
 
         checkMissingArguments<UploadProguardCommandOptions>(options, ['privateKey', 'application', 'version', 'folderPath', 'env']);
 
-        await ProguardService.upload(application, version, repoName, commitHash, orgName, folderPath, env, privateKey);
+        const service: ProguardService = new ProguardService();
+
+        await service.upload(application, version, repoName, commitHash, orgName, folderPath, env, privateKey);
       } catch (error) {
         consoleError(error);
       }

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

@@ -1,7 +1,7 @@
 import { Command } from 'commander';
 import { validateEnvironment } from '../../validators';
 import { checkMissingArguments, consoleError } from '../../../utils/shared.utils';
-import { ReactNativeService } from '../../../services/react-native.service';
+import { ReactNativeService } from '../../../services/react-native/react-native.service';
 import { UploadReactNativeSourceMapsCommandOptions } from '../../../models/react-native-commands.model';
 
 export const uploadReactNativeSourceMapsCommand = () => {
@@ -32,7 +32,9 @@ export const uploadReactNativeSourceMapsCommand = () => {
           'env',
         ]);
 
-        await ReactNativeService.upload(application, version, repoName, commitHash, orgName, folderPath, env, privateKey);
+        const service: ReactNativeService = new ReactNativeService();
+
+        await service.upload(application, version, repoName, commitHash, orgName, folderPath, env, privateKey);
       } catch (error) {
         consoleError(error);
       }

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

@@ -1,6 +1,6 @@
 import { Command } from 'commander';
 import { validateEnvironment } from '../../validators';
-import { SourceMapsService } from '../../../services/source-maps.service';
+import { SourceMapsService } from '../../../services/source-maps/source-maps.service';
 import { checkMissingArguments, consoleError } from '../../../utils/shared.utils';
 import { UploadSourceMapsCommandOptions } from '../../../models/source-maps-commands.model';
 
@@ -26,7 +26,9 @@ export const uploadSourceMapsCommand = () => {
 
         checkMissingArguments<UploadSourceMapsCommandOptions>(options, ['privateKey', 'application', 'version', 'folderPath', 'env']);
 
-        await SourceMapsService.upload(application, version, repoName, commitHash, orgName, folderPath, env, privateKey);
+        const service: SourceMapsService = new SourceMapsService();
+
+        await service.upload(application, version, repoName, commitHash, orgName, folderPath, env, privateKey);
       } catch (error) {
         consoleError(error);
       }

package/cli/rum-cli.ts

@@ -1,31 +1,31 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
-import sourceMapsCommands from './commands/source-maps';
-import reactNativeCommands from './commands/react-native';
-import dsymCommands from './commands/dsym';
-import proguardCommands from './commands/proguard';
+import { uploadSourceMapsCommand } from './commands/source-maps/upload-source-maps-command';
+import { uploadReactNativeSourceMapsCommand } from './commands/react-native/upload-react-native-source-maps-command';
+import { uploadDsymCommand } from './commands/dsym/upload-dsym-command';
+import { uploadProguardCommand } from './commands/proguard/upload-proguard-command';
 
 const program: Command = new Command();
 
 program.name('coralogix-rum-cli').description('CLI for upload, update, and delete source maps');
 
 // Create instances for each command
-const uploadSourceMapCommand: Command = sourceMapsCommands.uploadSourceMapsCommand();
+const sourceMapsCommand: Command = uploadSourceMapsCommand();
 
-const uploadReactNativeSourceMapsCommand: Command = reactNativeCommands.uploadReactNativeSourceMapsCommand();
+const reactNativeSourceMapsCommand: Command = uploadReactNativeSourceMapsCommand();
 
-const uploadDsymCommand: Command = dsymCommands.uploadDsymCommand();
+const dsymCommand: Command = uploadDsymCommand();
 
-const uploadProguardCommand: Command = proguardCommands.uploadProguardCommand();
+const proguardCommand: Command = uploadProguardCommand();
 
 // Register commands
-program.addCommand(uploadSourceMapCommand);
+program.addCommand(sourceMapsCommand);
 
-program.addCommand(uploadReactNativeSourceMapsCommand);
+program.addCommand(reactNativeSourceMapsCommand);
 
-program.addCommand(uploadDsymCommand);
+program.addCommand(dsymCommand);
 
-program.addCommand(uploadProguardCommand);
+program.addCommand(proguardCommand);
 
 // Parse command line arguments
 program.parse(process.argv);

package/config/config.ts

@@ -6,8 +6,6 @@ export interface LoggerConfig {
 }
 
 export interface rumApiConfig {
-  sourceMapsMaxMessageSize: number;
-  dsymMaxMessageSize: number;
   keepaliveTimeMs: number;
   keepaliveTimeoutMs: number;
   chunkSize: number;
@@ -30,8 +28,6 @@ const config: Config = {
   rumApi: {
     keepaliveTimeMs: 240000,
     keepaliveTimeoutMs: 240000,
-    sourceMapsMaxMessageSize: 200 * MB, // 200MB(in bytes)
-    dsymMaxMessageSize: 400 * MB, // 400MB(in bytes)
     reactNativeMaxCompressedFilesSize: 200 * MB, // 200MB (in bytes)
     sourceMapsMaxCompressedFilesSize: 200 * MB, // 200MB (in bytes)
     proguardMaxCompressedFilesSize: 200 * MB, // 200MB (in bytes)

package/dist/api/base/base.api.d.ts

@@ -0,0 +1,17 @@
+import { UploadBlobRequest } from '../../proto-models/com/coralogix/blobset/v2/blobset_service';
+import { EntityType } from '../../proto-models/com/coralogix/blobset/v2/entity_type';
+import { ReleaseEntityType } from '../../proto-models/com/coralogix/rum/v2/release_entity_type';
+import { EntityMetadata } from '../../proto-models/com/coralogix/blobset/v2/entity_metadata';
+import { ReleaseEntityMetadata } from '../../proto-models/com/coralogix/rum/v2/release_entity_metadata';
+export declare abstract class BaseApi {
+    protected abstract getEntityType(): EntityType;
+    protected abstract getReleaseEntityType(): ReleaseEntityType;
+    protected abstract getMaxCompressedFileSize(): number;
+    protected abstract buildReleaseEntityMetadata(application: string, version: string, repoName?: string, commitHash?: string, orgName?: string): ReleaseEntityMetadata;
+    protected abstract buildEntityMetadata(application: string, version: string, repoName?: string, commitHash?: string, orgName?: string): EntityMetadata;
+    private uploadBlob;
+    private createEntityRelease;
+    private createGrpcMetadata;
+    private checkEntityReleaseExists;
+    upload(request: UploadBlobRequest, application: string, version: string, repoName: string | undefined, commitHash: string | undefined, orgName: string | undefined, env: string, privateKey: string): Promise<void>;
+}

package/dist/api/base/base.api.js

@@ -0,0 +1,70 @@
+"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.BaseApi = void 0;
+const nice_grpc_1 = require("nice-grpc");
+const shared_utils_1 = require("../../utils/shared.utils");
+const grpc_client_factory_1 = require("../../grpc-client/grpc-client-factory");
+class BaseApi {
+    uploadBlob(blobSetClient, request, entityMetadata, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            request.entityMetadata = entityMetadata;
+            request.entityType = this.getEntityType();
+            const iterableRequest = (0, shared_utils_1.createUploadBlobRequestChunks)(request);
+            yield blobSetClient.uploadBlob(iterableRequest, { metadata });
+        });
+    }
+    createEntityRelease(rumSourceMapClient, releaseEntityMetadata, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const request = {
+                releaseEntityType: this.getReleaseEntityType(),
+                releaseEntityMetadata,
+            };
+            yield rumSourceMapClient.createEntityRelease(request, { metadata });
+        });
+    }
+    createGrpcMetadata(privateKey) {
+        const metadata = new nice_grpc_1.Metadata();
+        metadata.set('Authorization', `Bearer ${privateKey}`);
+        return metadata;
+    }
+    checkEntityReleaseExists(rumSourceMapClient, application, version, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { exists } = yield rumSourceMapClient.isEntityReleaseExists({ releaseId: version, application, releaseEntityType: this.getReleaseEntityType() }, { metadata });
+            return exists;
+        });
+    }
+    upload(request, application, version, repoName, commitHash, orgName, env, privateKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const metadata = this.createGrpcMetadata(privateKey);
+            const blobSetClient = grpc_client_factory_1.GrpcClientFactory.getBlobSetGrpcClient(env, this.getMaxCompressedFileSize());
+            const rumSourceMapClient = grpc_client_factory_1.GrpcClientFactory.getRumSourceMapGrpcClient(env, this.getMaxCompressedFileSize());
+            try {
+                (0, shared_utils_1.validateCompressedFilesSize)(request.data.length, this.getMaxCompressedFileSize());
+                const releaseExists = yield this.checkEntityReleaseExists(rumSourceMapClient, application, version, metadata);
+                if (releaseExists) {
+                    (0, shared_utils_1.consoleError)(`Entity release already exists for releaseId: ${version} and application: ${application}`);
+                    return;
+                }
+                const releaseEntityMetadata = this.buildReleaseEntityMetadata(application, version, repoName, commitHash, orgName);
+                const entityMetadata = this.buildEntityMetadata(application, version, repoName, commitHash, orgName);
+                yield this.uploadBlob(blobSetClient, request, entityMetadata, metadata);
+                yield this.createEntityRelease(rumSourceMapClient, releaseEntityMetadata, metadata);
+            }
+            catch (error) {
+                (0, shared_utils_1.consoleError)(`Failed to upload: ${error}`);
+                throw error;
+            }
+        });
+    }
+}
+exports.BaseApi = BaseApi;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.api.js","sourceRoot":"","sources":["../../../api/base/base.api.ts"],"names":[],"mappings":"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","sourcesContent":["import { Client, Metadata } from 'nice-grpc';\nimport { BlobSetServiceDefinition, UploadBlobRequest } from '../../proto-models/com/coralogix/blobset/v2/blobset_service';\nimport { consoleError, createUploadBlobRequestChunks, validateCompressedFilesSize } from '../../utils/shared.utils';\nimport { GrpcClientFactory } from '../../grpc-client/grpc-client-factory';\nimport { CreateEntityReleaseRequest, RumSourceMapServiceDefinition } from '../../proto-models/com/coralogix/rum/v2/rum_source_map_service';\nimport { EntityType } from '../../proto-models/com/coralogix/blobset/v2/entity_type';\nimport { ReleaseEntityType } from '../../proto-models/com/coralogix/rum/v2/release_entity_type';\nimport { EntityMetadata } from '../../proto-models/com/coralogix/blobset/v2/entity_metadata';\nimport { ReleaseEntityMetadata } from '../../proto-models/com/coralogix/rum/v2/release_entity_metadata';\n\nexport abstract class BaseApi {\n  protected abstract getEntityType(): EntityType;\n  protected abstract getReleaseEntityType(): ReleaseEntityType;\n  protected abstract getMaxCompressedFileSize(): number;\n  protected abstract buildReleaseEntityMetadata(\n    application: string,\n    version: string,\n    repoName?: string,\n    commitHash?: string,\n    orgName?: string,\n  ): ReleaseEntityMetadata;\n  protected abstract buildEntityMetadata(\n    application: string,\n    version: string,\n    repoName?: string,\n    commitHash?: string,\n    orgName?: string,\n  ): EntityMetadata;\n\n  private async uploadBlob(\n    blobSetClient: Client<typeof BlobSetServiceDefinition>,\n    request: UploadBlobRequest,\n    entityMetadata: EntityMetadata | undefined,\n    metadata: Metadata,\n  ): Promise<void> {\n    request.entityMetadata = entityMetadata;\n    request.entityType = this.getEntityType();\n\n    const iterableRequest = createUploadBlobRequestChunks(request);\n\n    await blobSetClient.uploadBlob(iterableRequest, { metadata });\n  }\n\n  private async createEntityRelease(\n    rumSourceMapClient: Client<typeof RumSourceMapServiceDefinition>,\n    releaseEntityMetadata: ReleaseEntityMetadata | undefined,\n    metadata: Metadata,\n  ): Promise<void> {\n    const request: CreateEntityReleaseRequest = {\n      releaseEntityType: this.getReleaseEntityType(),\n      releaseEntityMetadata,\n    };\n\n    await rumSourceMapClient.createEntityRelease(request, { metadata });\n  }\n\n  private createGrpcMetadata(privateKey: string): Metadata {\n    const metadata: Metadata = new Metadata();\n    metadata.set('Authorization', `Bearer ${privateKey}`);\n    return metadata;\n  }\n\n  private async checkEntityReleaseExists(\n    rumSourceMapClient: Client<typeof RumSourceMapServiceDefinition>,\n    application: string,\n    version: string,\n    metadata: Metadata,\n  ): Promise<boolean> {\n    const { exists } = await rumSourceMapClient.isEntityReleaseExists(\n      { releaseId: version, application, releaseEntityType: this.getReleaseEntityType() },\n      { metadata },\n    );\n    return exists;\n  }\n\n  public async upload(\n    request: UploadBlobRequest,\n    application: string,\n    version: string,\n    repoName: string | undefined,\n    commitHash: string | undefined,\n    orgName: string | undefined,\n    env: string,\n    privateKey: string,\n  ): Promise<void> {\n    const metadata: Metadata = this.createGrpcMetadata(privateKey);\n    const blobSetClient = GrpcClientFactory.getBlobSetGrpcClient(env, this.getMaxCompressedFileSize());\n    const rumSourceMapClient = GrpcClientFactory.getRumSourceMapGrpcClient(env, this.getMaxCompressedFileSize());\n\n    try {\n      validateCompressedFilesSize(request.data.length, this.getMaxCompressedFileSize());\n\n      const releaseExists: boolean = await this.checkEntityReleaseExists(rumSourceMapClient, application, version, metadata);\n\n      if (releaseExists) {\n        consoleError(`Entity release already exists for releaseId: ${version} and application: ${application}`);\n        return;\n      }\n\n      const releaseEntityMetadata: ReleaseEntityMetadata = this.buildReleaseEntityMetadata(\n        application,\n        version,\n        repoName,\n        commitHash,\n        orgName,\n      );\n\n      const entityMetadata: EntityMetadata = this.buildEntityMetadata(application, version, repoName, commitHash, orgName);\n\n      await this.uploadBlob(blobSetClient, request, entityMetadata, metadata);\n\n      await this.createEntityRelease(rumSourceMapClient, releaseEntityMetadata, metadata);\n    } catch (error) {\n      consoleError(`Failed to upload: ${error}`);\n      throw error;\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,12 @@
+import { EntityType } from '../../proto-models/com/coralogix/blobset/v2/entity_type';
+import { ReleaseEntityType } from '../../proto-models/com/coralogix/rum/v2/release_entity_type';
+import { BaseApi } from '../base/base.api';
+import { ReleaseEntityMetadata } from '../../proto-models/com/coralogix/rum/v2/release_entity_metadata';
+import { EntityMetadata } from '../../proto-models/com/coralogix/blobset/v2/entity_metadata';
+export declare class DsymApi extends BaseApi {
+    protected getEntityType(): EntityType;
+    protected getReleaseEntityType(): ReleaseEntityType;
+    protected getMaxCompressedFileSize(): number;
+    protected buildReleaseEntityMetadata(application: string, version: string, repoName?: string, commitHash?: string, orgName?: string): ReleaseEntityMetadata;
+    protected buildEntityMetadata(application: string, version: string, repoName?: string, commitHash?: string, orgName?: string): EntityMetadata;
+}