@coralogix/rum-cli 1.1.37 → 1.1.41

package/README.md

@@ -68,7 +68,7 @@ coralogix-rum-cli upload-proguard -k <privateKey> -a <application> -v <version>
 - `-c, --commit-hash <commitHash>`: GitHub commit hash (optional).
 - `-n, --repo-name <repoName>`: GitHub repository name (optional).
 - `-o, --org-name <orgName>`: GitHub organization name (optional).
-- `-g, --generate`: Update existing release or create a new one if not found (optional).
+- `--override`: Override existing source maps (optional).
 - `-h, --help`: Display help.
 
 ## Environments

package/api/base/base.api.ts

@@ -1,6 +1,6 @@
 import { Client, ClientError, Metadata, Status } from 'nice-grpc';
 import { BlobSetServiceDefinition, UploadBlobRequest } from '../../proto-models/com/coralogix/blobset/v2/blobset_service';
-import { consoleError, createUploadBlobRequestChunks, validateCompressedFilesSize } from '../../utils/shared.utils';
+import { 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';
@@ -18,6 +18,7 @@ export abstract class BaseApi {
     repoName?: string,
     commitHash?: string,
     orgName?: string,
+    internalVersion?: number,
   ): ReleaseEntityMetadata;
   protected abstract buildEntityMetadata(
     application: string,
@@ -25,9 +26,10 @@ export abstract class BaseApi {
     repoName?: string,
     commitHash?: string,
     orgName?: string,
+    internalVersion?: number,
   ): EntityMetadata;
 
-  private async uploadBlob(
+  protected async uploadBlob(
     blobSetClient: Client<typeof BlobSetServiceDefinition>,
     request: UploadBlobRequest,
     entityMetadata: EntityMetadata | undefined,
@@ -41,8 +43,8 @@ export abstract class BaseApi {
     await blobSetClient.uploadBlob(iterableRequest, { metadata });
   }
 
-  private async createEntityRelease(
-    rumSourceMapClient: Client<typeof RumSourceMapServiceDefinition>,
+  protected async createEntityRelease(
+    rumClient: Client<typeof RumSourceMapServiceDefinition>,
     releaseEntityMetadata: ReleaseEntityMetadata | undefined,
     metadata: Metadata,
   ): Promise<void> {
@@ -51,23 +53,23 @@ export abstract class BaseApi {
       releaseEntityMetadata,
     };
 
-    await rumSourceMapClient.createEntityRelease(request, { metadata });
+    await rumClient.createEntityRelease(request, { metadata });
   }
 
-  private createGrpcMetadata(privateKey: string): Metadata {
+  protected createGrpcMetadata(privateKey: string): Metadata {
     const metadata: Metadata = new Metadata();
     metadata.set('Authorization', `Bearer ${privateKey}`);
     return metadata;
   }
 
-  private async checkEntityReleaseExists(
-    rumSourceMapClient: Client<typeof RumSourceMapServiceDefinition>,
+  protected async checkEntityReleaseExists(
+    rumClient: Client<typeof RumSourceMapServiceDefinition>,
     application: string,
     version: string,
     metadata: Metadata,
   ): Promise<boolean> {
     try {
-      const { exists } = await rumSourceMapClient.isEntityReleaseExists(
+      const { exists } = await rumClient.isEntityReleaseExists(
         { releaseId: version, application, releaseEntityType: this.getReleaseEntityType() },
         { metadata },
       );
@@ -94,32 +96,27 @@ export abstract class BaseApi {
   ): Promise<void> {
     const metadata: Metadata = this.createGrpcMetadata(privateKey);
     const blobSetClient = GrpcClientFactory.getBlobSetGrpcClient(env, this.getMaxCompressedFileSize());
-    const rumSourceMapClient = GrpcClientFactory.getRumSourceMapGrpcClient(env, this.getMaxCompressedFileSize());
+    const rumClient = GrpcClientFactory.getRumSourceMapGrpcClient(env, this.getMaxCompressedFileSize());
 
-    try {
-      validateCompressedFilesSize(request.data.length, this.getMaxCompressedFileSize());
-
-      const releaseExists: boolean = await this.checkEntityReleaseExists(rumSourceMapClient, application, version, metadata);
+    validateCompressedFilesSize(request.data.length, this.getMaxCompressedFileSize());
 
-      if (releaseExists) {
-        throw new Error(`Entity release already exists for releaseId: ${version} and application: ${application}`);
-      }
+    const releaseExists = await this.checkEntityReleaseExists(rumClient, application, version, metadata);
 
-      const releaseEntityMetadata: ReleaseEntityMetadata = this.buildReleaseEntityMetadata(
-        application,
-        version,
-        repoName,
-        commitHash,
-        orgName,
-      );
+    if (releaseExists) {
+      throw new Error(`Entity release already exists for releaseId: ${version} and application: ${application}`);
+    }
 
-      const entityMetadata: EntityMetadata = this.buildEntityMetadata(application, version, repoName, commitHash, orgName);
+    const releaseEntityMetadata: ReleaseEntityMetadata = this.buildReleaseEntityMetadata(
+      application,
+      version,
+      repoName,
+      commitHash,
+      orgName,
+    );
 
-      await this.uploadBlob(blobSetClient, request, entityMetadata, metadata);
+    const entityMetadata: EntityMetadata = this.buildEntityMetadata(application, version, repoName, commitHash, orgName);
 
-      await this.createEntityRelease(rumSourceMapClient, releaseEntityMetadata, metadata);
-    } catch (error) {
-      throw error;
-    }
+    await this.uploadBlob(blobSetClient, request, entityMetadata, metadata);
+    await this.createEntityRelease(rumClient, releaseEntityMetadata, metadata);
   }
 }

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

@@ -4,6 +4,11 @@ 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';
+import { UploadBlobRequest } from '../../proto-models/com/coralogix/blobset/v2/blobset_service';
+import { Client, ClientError, Metadata, Status } from 'nice-grpc';
+import { GrpcClientFactory } from '../../grpc-client/grpc-client-factory';
+import { validateCompressedFilesSize } from '../../utils/shared.utils';
+import { RumSourceMapServiceDefinition } from '../../proto-models/com/coralogix/rum/v2/rum_source_map_service';
 
 export class SourceMapsApi extends BaseApi {
   protected getEntityType(): EntityType {
@@ -24,6 +29,7 @@ export class SourceMapsApi extends BaseApi {
     repoName?: string,
     commitHash?: string,
     orgName?: string,
+    internalVersion?: number,
   ): ReleaseEntityMetadata {
     return {
       metadata: {
@@ -34,6 +40,7 @@ export class SourceMapsApi extends BaseApi {
           repoName: repoName || '',
           commitHash: commitHash || '',
           orgName: orgName || '',
+          internalVersion: internalVersion ?? 0,
         },
       },
     };
@@ -45,6 +52,7 @@ export class SourceMapsApi extends BaseApi {
     repoName?: string,
     commitHash?: string,
     orgName?: string,
+    internalVersion?: number,
   ): EntityMetadata {
     return {
       metadata: {
@@ -55,8 +63,78 @@ export class SourceMapsApi extends BaseApi {
           repoName: repoName || '',
           commitHash: commitHash || '',
           orgName: orgName || '',
+          internalVersion: internalVersion ?? 0,
         },
       },
     };
   }
+
+  public async upload(
+    request: UploadBlobRequest,
+    application: string,
+    version: string,
+    repoName: string | undefined,
+    commitHash: string | undefined,
+    orgName: string | undefined,
+    env: string,
+    privateKey: string,
+    override = false,
+  ): Promise<void> {
+    const metadata: Metadata = this.createGrpcMetadata(privateKey);
+    const blobSetClient = GrpcClientFactory.getBlobSetGrpcClient(env, this.getMaxCompressedFileSize());
+    const rumClient = GrpcClientFactory.getRumSourceMapGrpcClient(env, this.getMaxCompressedFileSize());
+
+    validateCompressedFilesSize(request.data.length, this.getMaxCompressedFileSize());
+
+    let internalVersion: number | undefined;
+
+    if (override) {
+      internalVersion = await this.updateInternalVersion(rumClient, application, version, metadata);
+    } else {
+      const releaseExists = await this.checkEntityReleaseExists(rumClient, application, version, metadata);
+
+      if (releaseExists) {
+        throw new Error(`Entity release already exists for releaseId: ${version} and application: ${application}`);
+      }
+    }
+
+    const releaseEntityMetadata: ReleaseEntityMetadata = this.buildReleaseEntityMetadata(
+      application,
+      version,
+      repoName,
+      commitHash,
+      orgName,
+      internalVersion,
+    );
+
+    const entityMetadata: EntityMetadata = this.buildEntityMetadata(application, version, repoName, commitHash, orgName, internalVersion);
+
+    await this.uploadBlob(blobSetClient, request, entityMetadata, metadata);
+    await this.createEntityRelease(rumClient, releaseEntityMetadata, metadata);
+  }
+
+  private async updateInternalVersion(
+    client: Client<typeof RumSourceMapServiceDefinition>,
+    application: string,
+    version: string,
+    metadata: Metadata,
+  ): Promise<number> {
+    try {
+      const { latestVersion } = await client.getLatestInternalVersion(
+        {
+          application,
+          releaseId: version,
+          releaseEntityType: this.getReleaseEntityType(),
+        },
+        { metadata },
+      );
+
+      return (latestVersion ?? -1) + 1;
+    } catch (error) {
+      if (error instanceof ClientError && error.code === Status.PERMISSION_DENIED) {
+        throw new Error(`Permission denied: Verify private key. Details: ${error.message}`);
+      }
+      throw error;
+    }
+  }
 }

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

@@ -14,6 +14,7 @@ export const uploadSourceMapsCommand = () => {
     .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('--override', 'Override existing source maps (optional)')
     .description('Update source maps')
     .action(async (options: UploadSourceMapsCommandOptions) => {
       try {
@@ -22,13 +23,13 @@ export const uploadSourceMapsCommand = () => {
           process.exit(0);
         }
 
-        const { privateKey, application, version, folderPath, commitHash, repoName, orgName, env } = options;
+        const { privateKey, application, version, folderPath, commitHash, repoName, orgName, env, override } = options;
 
         checkMissingArguments<UploadSourceMapsCommandOptions>(options, ['privateKey', 'application', 'version', 'folderPath', 'env']);
 
         const service: SourceMapsService = new SourceMapsService();
 
-        await service.upload(application, version, repoName, commitHash, orgName, folderPath, env, privateKey);
+        await service.upload(application, version, repoName, commitHash, orgName, folderPath, env, privateKey, override);
       } catch (error) {
         consoleError(error);
       }

package/consts/consts.ts

@@ -16,4 +16,5 @@ export const envToDomain: Record<string, string> = {
   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)
   AP3: 'https://ng-api-grpc.ap3.coralogix.com:443', // ap-southeast-3 (Jakarta)
+  STG: 'https://ng-api-grpc.app.staging.coralogix.net:443',
 };

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

@@ -1,4 +1,6 @@
-import { UploadBlobRequest } from '../../proto-models/com/coralogix/blobset/v2/blobset_service';
+import { Client, Metadata } from 'nice-grpc';
+import { BlobSetServiceDefinition, UploadBlobRequest } from '../../proto-models/com/coralogix/blobset/v2/blobset_service';
+import { 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';
@@ -7,11 +9,11 @@ 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;
+    protected abstract buildReleaseEntityMetadata(application: string, version: string, repoName?: string, commitHash?: string, orgName?: string, internalVersion?: number): ReleaseEntityMetadata;
+    protected abstract buildEntityMetadata(application: string, version: string, repoName?: string, commitHash?: string, orgName?: string, internalVersion?: number): EntityMetadata;
+    protected uploadBlob(blobSetClient: Client<typeof BlobSetServiceDefinition>, request: UploadBlobRequest, entityMetadata: EntityMetadata | undefined, metadata: Metadata): Promise<void>;
+    protected createEntityRelease(rumClient: Client<typeof RumSourceMapServiceDefinition>, releaseEntityMetadata: ReleaseEntityMetadata | undefined, metadata: Metadata): Promise<void>;
+    protected createGrpcMetadata(privateKey: string): Metadata;
+    protected checkEntityReleaseExists(rumClient: Client<typeof RumSourceMapServiceDefinition>, application: string, version: string, metadata: Metadata): Promise<boolean>;
     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

@@ -22,13 +22,13 @@ class BaseApi {
             yield blobSetClient.uploadBlob(iterableRequest, { metadata });
         });
     }
-    createEntityRelease(rumSourceMapClient, releaseEntityMetadata, metadata) {
+    createEntityRelease(rumClient, releaseEntityMetadata, metadata) {
         return __awaiter(this, void 0, void 0, function* () {
             const request = {
                 releaseEntityType: this.getReleaseEntityType(),
                 releaseEntityMetadata,
             };
-            yield rumSourceMapClient.createEntityRelease(request, { metadata });
+            yield rumClient.createEntityRelease(request, { metadata });
         });
     }
     createGrpcMetadata(privateKey) {
@@ -36,10 +36,10 @@ class BaseApi {
         metadata.set('Authorization', `Bearer ${privateKey}`);
         return metadata;
     }
-    checkEntityReleaseExists(rumSourceMapClient, application, version, metadata) {
+    checkEntityReleaseExists(rumClient, application, version, metadata) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const { exists } = yield rumSourceMapClient.isEntityReleaseExists({ releaseId: version, application, releaseEntityType: this.getReleaseEntityType() }, { metadata });
+                const { exists } = yield rumClient.isEntityReleaseExists({ releaseId: version, application, releaseEntityType: this.getReleaseEntityType() }, { metadata });
                 return exists;
             }
             catch (error) {
@@ -54,23 +54,18 @@ class BaseApi {
         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) {
-                    throw new Error(`Entity release already exists for releaseId: ${version} and application: ${application}`);
-                }
-                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) {
-                throw error;
+            const rumClient = grpc_client_factory_1.GrpcClientFactory.getRumSourceMapGrpcClient(env, this.getMaxCompressedFileSize());
+            (0, shared_utils_1.validateCompressedFilesSize)(request.data.length, this.getMaxCompressedFileSize());
+            const releaseExists = yield this.checkEntityReleaseExists(rumClient, application, version, metadata);
+            if (releaseExists) {
+                throw new Error(`Entity release already exists for releaseId: ${version} and application: ${application}`);
             }
+            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(rumClient, releaseEntityMetadata, metadata);
         });
     }
 }
 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, ClientError, Metadata, Status } 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    try {\n      const { exists } = await rumSourceMapClient.isEntityReleaseExists(\n        { releaseId: version, application, releaseEntityType: this.getReleaseEntityType() },\n        { metadata },\n      );\n      return exists;\n    } catch (error) {\n      if (error instanceof ClientError && error.code === Status.PERMISSION_DENIED) {\n        throw new Error(\n          `Permission denied while checking entity release. Verify that your private key is correct. Details: ${error.message}`,\n        );\n      }\n      throw error;\n    }\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        throw new Error(`Entity release already exists for releaseId: ${version} and application: ${application}`);\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      throw error;\n    }\n  }\n}\n"]}
+//# 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, ClientError, Metadata, Status } from 'nice-grpc';\nimport { BlobSetServiceDefinition, UploadBlobRequest } from '../../proto-models/com/coralogix/blobset/v2/blobset_service';\nimport { 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    internalVersion?: number,\n  ): ReleaseEntityMetadata;\n  protected abstract buildEntityMetadata(\n    application: string,\n    version: string,\n    repoName?: string,\n    commitHash?: string,\n    orgName?: string,\n    internalVersion?: number,\n  ): EntityMetadata;\n\n  protected 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  protected async createEntityRelease(\n    rumClient: 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 rumClient.createEntityRelease(request, { metadata });\n  }\n\n  protected createGrpcMetadata(privateKey: string): Metadata {\n    const metadata: Metadata = new Metadata();\n    metadata.set('Authorization', `Bearer ${privateKey}`);\n    return metadata;\n  }\n\n  protected async checkEntityReleaseExists(\n    rumClient: Client<typeof RumSourceMapServiceDefinition>,\n    application: string,\n    version: string,\n    metadata: Metadata,\n  ): Promise<boolean> {\n    try {\n      const { exists } = await rumClient.isEntityReleaseExists(\n        { releaseId: version, application, releaseEntityType: this.getReleaseEntityType() },\n        { metadata },\n      );\n      return exists;\n    } catch (error) {\n      if (error instanceof ClientError && error.code === Status.PERMISSION_DENIED) {\n        throw new Error(\n          `Permission denied while checking entity release. Verify that your private key is correct. Details: ${error.message}`,\n        );\n      }\n      throw error;\n    }\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 rumClient = GrpcClientFactory.getRumSourceMapGrpcClient(env, this.getMaxCompressedFileSize());\n\n    validateCompressedFilesSize(request.data.length, this.getMaxCompressedFileSize());\n\n    const releaseExists = await this.checkEntityReleaseExists(rumClient, application, version, metadata);\n\n    if (releaseExists) {\n      throw new Error(`Entity release already exists for releaseId: ${version} and application: ${application}`);\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    await this.createEntityRelease(rumClient, releaseEntityMetadata, metadata);\n  }\n}\n"]}

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

@@ -3,10 +3,13 @@ import { ReleaseEntityType } from '../../proto-models/com/coralogix/rum/v2/relea
 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';
+import { UploadBlobRequest } from '../../proto-models/com/coralogix/blobset/v2/blobset_service';
 export declare class SourceMapsApi 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;
+    protected buildReleaseEntityMetadata(application: string, version: string, repoName?: string, commitHash?: string, orgName?: string, internalVersion?: number): ReleaseEntityMetadata;
+    protected buildEntityMetadata(application: string, version: string, repoName?: string, commitHash?: string, orgName?: string, internalVersion?: number): EntityMetadata;
+    upload(request: UploadBlobRequest, application: string, version: string, repoName: string | undefined, commitHash: string | undefined, orgName: string | undefined, env: string, privateKey: string, override?: boolean): Promise<void>;
+    private updateInternalVersion;
 }

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

@@ -1,4 +1,13 @@
 "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 };
 };
@@ -8,6 +17,9 @@ const entity_type_1 = require("../../proto-models/com/coralogix/blobset/v2/entit
 const release_entity_type_1 = require("../../proto-models/com/coralogix/rum/v2/release_entity_type");
 const config_1 = __importDefault(require("../../config/config"));
 const base_api_1 = require("../base/base.api");
+const nice_grpc_1 = require("nice-grpc");
+const grpc_client_factory_1 = require("../../grpc-client/grpc-client-factory");
+const shared_utils_1 = require("../../utils/shared.utils");
 class SourceMapsApi extends base_api_1.BaseApi {
     getEntityType() {
         return entity_type_1.EntityType.ENTITY_TYPE_SOURCE_MAP;
@@ -18,7 +30,7 @@ class SourceMapsApi extends base_api_1.BaseApi {
     getMaxCompressedFileSize() {
         return config_1.default.rumApi.sourceMapsMaxCompressedFilesSize;
     }
-    buildReleaseEntityMetadata(application, version, repoName, commitHash, orgName) {
+    buildReleaseEntityMetadata(application, version, repoName, commitHash, orgName, internalVersion) {
         return {
             metadata: {
                 $case: 'sourceMapMetadata',
@@ -28,11 +40,12 @@ class SourceMapsApi extends base_api_1.BaseApi {
                     repoName: repoName || '',
                     commitHash: commitHash || '',
                     orgName: orgName || '',
+                    internalVersion: internalVersion !== null && internalVersion !== void 0 ? internalVersion : 0,
                 },
             },
         };
     }
-    buildEntityMetadata(application, version, repoName, commitHash, orgName) {
+    buildEntityMetadata(application, version, repoName, commitHash, orgName, internalVersion) {
         return {
             metadata: {
                 $case: 'sourceMapMetadata',
@@ -42,10 +55,51 @@ class SourceMapsApi extends base_api_1.BaseApi {
                     repoName: repoName || '',
                     commitHash: commitHash || '',
                     orgName: orgName || '',
+                    internalVersion: internalVersion !== null && internalVersion !== void 0 ? internalVersion : 0,
                 },
             },
         };
     }
+    upload(request, application, version, repoName, commitHash, orgName, env, privateKey, override = false) {
+        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 rumClient = grpc_client_factory_1.GrpcClientFactory.getRumSourceMapGrpcClient(env, this.getMaxCompressedFileSize());
+            (0, shared_utils_1.validateCompressedFilesSize)(request.data.length, this.getMaxCompressedFileSize());
+            let internalVersion;
+            if (override) {
+                internalVersion = yield this.updateInternalVersion(rumClient, application, version, metadata);
+            }
+            else {
+                const releaseExists = yield this.checkEntityReleaseExists(rumClient, application, version, metadata);
+                if (releaseExists) {
+                    throw new Error(`Entity release already exists for releaseId: ${version} and application: ${application}`);
+                }
+            }
+            const releaseEntityMetadata = this.buildReleaseEntityMetadata(application, version, repoName, commitHash, orgName, internalVersion);
+            const entityMetadata = this.buildEntityMetadata(application, version, repoName, commitHash, orgName, internalVersion);
+            yield this.uploadBlob(blobSetClient, request, entityMetadata, metadata);
+            yield this.createEntityRelease(rumClient, releaseEntityMetadata, metadata);
+        });
+    }
+    updateInternalVersion(client, application, version, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { latestVersion } = yield client.getLatestInternalVersion({
+                    application,
+                    releaseId: version,
+                    releaseEntityType: this.getReleaseEntityType(),
+                }, { metadata });
+                return (latestVersion !== null && latestVersion !== void 0 ? latestVersion : -1) + 1;
+            }
+            catch (error) {
+                if (error instanceof nice_grpc_1.ClientError && error.code === nice_grpc_1.Status.PERMISSION_DENIED) {
+                    throw new Error(`Permission denied: Verify private key. Details: ${error.message}`);
+                }
+                throw error;
+            }
+        });
+    }
 }
 exports.SourceMapsApi = SourceMapsApi;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"source-maps.api.js","sourceRoot":"","sources":["../../../api/source-maps/source-maps.api.ts"],"names":[],"mappings":"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","sourcesContent":["import { EntityType } from '../../proto-models/com/coralogix/blobset/v2/entity_type';\nimport { ReleaseEntityType } from '../../proto-models/com/coralogix/rum/v2/release_entity_type';\nimport config from '../../config/config';\nimport { BaseApi } from '../base/base.api';\nimport { ReleaseEntityMetadata } from '../../proto-models/com/coralogix/rum/v2/release_entity_metadata';\nimport { EntityMetadata } from '../../proto-models/com/coralogix/blobset/v2/entity_metadata';\nimport { UploadBlobRequest } from '../../proto-models/com/coralogix/blobset/v2/blobset_service';\nimport { Client, ClientError, Metadata, Status } from 'nice-grpc';\nimport { GrpcClientFactory } from '../../grpc-client/grpc-client-factory';\nimport { validateCompressedFilesSize } from '../../utils/shared.utils';\nimport { RumSourceMapServiceDefinition } from '../../proto-models/com/coralogix/rum/v2/rum_source_map_service';\n\nexport class SourceMapsApi extends BaseApi {\n  protected getEntityType(): EntityType {\n    return EntityType.ENTITY_TYPE_SOURCE_MAP;\n  }\n\n  protected getReleaseEntityType(): ReleaseEntityType {\n    return ReleaseEntityType.RELEASE_ENTITY_TYPE_SOURCE_MAP;\n  }\n\n  protected getMaxCompressedFileSize(): number {\n    return config.rumApi.sourceMapsMaxCompressedFilesSize;\n  }\n\n  protected buildReleaseEntityMetadata(\n    application: string,\n    version: string,\n    repoName?: string,\n    commitHash?: string,\n    orgName?: string,\n    internalVersion?: number,\n  ): ReleaseEntityMetadata {\n    return {\n      metadata: {\n        $case: 'sourceMapMetadata',\n        sourceMapMetadata: {\n          application,\n          releaseId: version,\n          repoName: repoName || '',\n          commitHash: commitHash || '',\n          orgName: orgName || '',\n          internalVersion: internalVersion ?? 0,\n        },\n      },\n    };\n  }\n\n  protected buildEntityMetadata(\n    application: string,\n    version: string,\n    repoName?: string,\n    commitHash?: string,\n    orgName?: string,\n    internalVersion?: number,\n  ): EntityMetadata {\n    return {\n      metadata: {\n        $case: 'sourceMapMetadata',\n        sourceMapMetadata: {\n          application,\n          releaseId: version,\n          repoName: repoName || '',\n          commitHash: commitHash || '',\n          orgName: orgName || '',\n          internalVersion: internalVersion ?? 0,\n        },\n      },\n    };\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    override = false,\n  ): Promise<void> {\n    const metadata: Metadata = this.createGrpcMetadata(privateKey);\n    const blobSetClient = GrpcClientFactory.getBlobSetGrpcClient(env, this.getMaxCompressedFileSize());\n    const rumClient = GrpcClientFactory.getRumSourceMapGrpcClient(env, this.getMaxCompressedFileSize());\n\n    validateCompressedFilesSize(request.data.length, this.getMaxCompressedFileSize());\n\n    let internalVersion: number | undefined;\n\n    if (override) {\n      internalVersion = await this.updateInternalVersion(rumClient, application, version, metadata);\n    } else {\n      const releaseExists = await this.checkEntityReleaseExists(rumClient, application, version, metadata);\n\n      if (releaseExists) {\n        throw new Error(`Entity release already exists for releaseId: ${version} and application: ${application}`);\n      }\n    }\n\n    const releaseEntityMetadata: ReleaseEntityMetadata = this.buildReleaseEntityMetadata(\n      application,\n      version,\n      repoName,\n      commitHash,\n      orgName,\n      internalVersion,\n    );\n\n    const entityMetadata: EntityMetadata = this.buildEntityMetadata(application, version, repoName, commitHash, orgName, internalVersion);\n\n    await this.uploadBlob(blobSetClient, request, entityMetadata, metadata);\n    await this.createEntityRelease(rumClient, releaseEntityMetadata, metadata);\n  }\n\n  private async updateInternalVersion(\n    client: Client<typeof RumSourceMapServiceDefinition>,\n    application: string,\n    version: string,\n    metadata: Metadata,\n  ): Promise<number> {\n    try {\n      const { latestVersion } = await client.getLatestInternalVersion(\n        {\n          application,\n          releaseId: version,\n          releaseEntityType: this.getReleaseEntityType(),\n        },\n        { metadata },\n      );\n\n      return (latestVersion ?? -1) + 1;\n    } catch (error) {\n      if (error instanceof ClientError && error.code === Status.PERMISSION_DENIED) {\n        throw new Error(`Permission denied: Verify private key. Details: ${error.message}`);\n      }\n      throw error;\n    }\n  }\n}\n"]}

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

@@ -24,6 +24,7 @@ const uploadSourceMapsCommand = () => {
         .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('--override', 'Override existing source maps (optional)')
         .description('Update source maps')
         .action((options) => __awaiter(void 0, void 0, void 0, function* () {
         try {
@@ -31,10 +32,10 @@ const uploadSourceMapsCommand = () => {
                 uploadCommand.outputHelp();
                 process.exit(0);
             }
-            const { privateKey, application, version, folderPath, commitHash, repoName, orgName, env } = options;
+            const { privateKey, application, version, folderPath, commitHash, repoName, orgName, env, override } = options;
             (0, shared_utils_1.checkMissingArguments)(options, ['privateKey', 'application', 'version', 'folderPath', 'env']);
             const service = new source_maps_service_1.SourceMapsService();
-            yield service.upload(application, version, repoName, commitHash, orgName, folderPath, env, privateKey);
+            yield service.upload(application, version, repoName, commitHash, orgName, folderPath, env, privateKey, override);
         }
         catch (error) {
             (0, shared_utils_1.consoleError)(error);
@@ -43,4 +44,4 @@ const uploadSourceMapsCommand = () => {
     return uploadCommand;
 };
 exports.uploadSourceMapsCommand = uploadSourceMapsCommand;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/consts/consts.js

@@ -13,6 +13,7 @@ exports.envToDomain = {
     US2: 'https://ng-api-grpc.cx498.coralogix.com:443',
     AP1: 'https://ng-api-grpc.app.coralogix.in:443',
     AP2: 'https://ng-api-grpc.coralogixsg.com:443',
-    AP3: 'https://ng-api-grpc.ap3.coralogix.com:443', // ap-southeast-3 (Jakarta)
+    AP3: 'https://ng-api-grpc.ap3.coralogix.com:443',
+    STG: 'https://ng-api-grpc.app.staging.coralogix.net:443',
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vY29uc3RzL2NvbnN0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBYSxRQUFBLEVBQUUsR0FBRyxJQUFJLEdBQUcsSUFBSSxDQUFDO0FBRWpCLFFBQUEsV0FBVyxHQUFHLG1CQUFtQixDQUFDO0FBRWxDLFFBQUEsU0FBUyxHQUFHLG1CQUFtQixDQUFDO0FBRWhDLFFBQUEsVUFBVSxHQUFHLG1CQUFtQixDQUFDO0FBRWpDLFFBQUEsaUJBQWlCLEdBQVcsRUFBRSxHQUFHLElBQUksR0FBRyxJQUFJLENBQUMsQ0FBQyxRQUFRO0FBRXRELFFBQUEsV0FBVyxHQUEyQjtJQUNqRCxHQUFHLEVBQUUsdUNBQXVDO0lBQzVDLEdBQUcsRUFBRSwyQ0FBMkM7SUFDaEQsR0FBRyxFQUFFLHNDQUFzQztJQUMzQyxHQUFHLEVBQUUsNkNBQTZDO0lBQ2xELEdBQUcsRUFBRSwwQ0FBMEM7SUFDL0MsR0FBRyxFQUFFLHlDQUF5QztJQUM5QyxHQUFHLEVBQUUsMkNBQTJDLEVBQUUsMkJBQTJCO0NBQzlFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgTUIgPSAxMDI0ICogMTAyNDtcblxuZXhwb3J0IGNvbnN0IEdSRUVOX0NPTE9SID0gJ1xceDFiWzMybSVzXFx4MWJbMG0nO1xuXG5leHBvcnQgY29uc3QgUkVEX0NPTE9SID0gJ1xceDFiWzMxbSVzXFx4MWJbMG0nO1xuXG5leHBvcnQgY29uc3QgR1JBWV9DT0xPUiA9ICdcXHgxYlszN20lc1xceDFiWzBtJztcblxuZXhwb3J0IGNvbnN0IFNUUkVBTV9DSFVOS19TSVpFOiBudW1iZXIgPSAxMCAqIDEwMjQgKiAxMDI0OyAvLyAxMCBNQlxuXG5leHBvcnQgY29uc3QgZW52VG9Eb21haW46IFJlY29yZDxzdHJpbmcsIHN0cmluZz4gPSB7XG4gIEVVMTogJ2h0dHBzOi8vbmctYXBpLWdycGMuY29yYWxvZ2l4LmNvbTo0NDMnLCAvLyBldS13ZXN0LTEgKElyZWxhbmQpXG4gIEVVMjogJ2h0dHBzOi8vbmctYXBpLWdycGMuZXUyLmNvcmFsb2dpeC5jb206NDQzJywgLy8gZXUtbm9ydGgtMSAoU3RvY2tob2xtKVxuICBVUzE6ICdodHRwczovL25nLWFwaS1ncnBjLmNvcmFsb2dpeC51czo0NDMnLCAvLyB1cy1lYXN0LTIgKE9oaW8pXG4gIFVTMjogJ2h0dHBzOi8vbmctYXBpLWdycGMuY3g0OTguY29yYWxvZ2l4LmNvbTo0NDMnLCAvLyB1cy13ZXN0LTIgKE9yZWdvbilcbiAgQVAxOiAnaHR0cHM6Ly9uZy1hcGktZ3JwYy5hcHAuY29yYWxvZ2l4LmluOjQ0MycsIC8vIGFwLXNvdXRoLTEgKE11bWJhaSlcbiAgQVAyOiAnaHR0cHM6Ly9uZy1hcGktZ3JwYy5jb3JhbG9naXhzZy5jb206NDQzJywgLy8gYXAtc291dGhlYXN0LTEgKFNpbmdhcG9yZSlcbiAgQVAzOiAnaHR0cHM6Ly9uZy1hcGktZ3JwYy5hcDMuY29yYWxvZ2l4LmNvbTo0NDMnLCAvLyBhcC1zb3V0aGVhc3QtMyAoSmFrYXJ0YSlcbn07XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vY29uc3RzL2NvbnN0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBYSxRQUFBLEVBQUUsR0FBRyxJQUFJLEdBQUcsSUFBSSxDQUFDO0FBRWpCLFFBQUEsV0FBVyxHQUFHLG1CQUFtQixDQUFDO0FBRWxDLFFBQUEsU0FBUyxHQUFHLG1CQUFtQixDQUFDO0FBRWhDLFFBQUEsVUFBVSxHQUFHLG1CQUFtQixDQUFDO0FBRWpDLFFBQUEsaUJBQWlCLEdBQVcsRUFBRSxHQUFHLElBQUksR0FBRyxJQUFJLENBQUMsQ0FBQyxRQUFRO0FBRXRELFFBQUEsV0FBVyxHQUEyQjtJQUNqRCxHQUFHLEVBQUUsdUNBQXVDO0lBQzVDLEdBQUcsRUFBRSwyQ0FBMkM7SUFDaEQsR0FBRyxFQUFFLHNDQUFzQztJQUMzQyxHQUFHLEVBQUUsNkNBQTZDO0lBQ2xELEdBQUcsRUFBRSwwQ0FBMEM7SUFDL0MsR0FBRyxFQUFFLHlDQUF5QztJQUM5QyxHQUFHLEVBQUUsMkNBQTJDO0lBQ2hELEdBQUcsRUFBRSxtREFBbUQ7Q0FDekQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBNQiA9IDEwMjQgKiAxMDI0O1xuXG5leHBvcnQgY29uc3QgR1JFRU5fQ09MT1IgPSAnXFx4MWJbMzJtJXNcXHgxYlswbSc7XG5cbmV4cG9ydCBjb25zdCBSRURfQ09MT1IgPSAnXFx4MWJbMzFtJXNcXHgxYlswbSc7XG5cbmV4cG9ydCBjb25zdCBHUkFZX0NPTE9SID0gJ1xceDFiWzM3bSVzXFx4MWJbMG0nO1xuXG5leHBvcnQgY29uc3QgU1RSRUFNX0NIVU5LX1NJWkU6IG51bWJlciA9IDEwICogMTAyNCAqIDEwMjQ7IC8vIDEwIE1CXG5cbmV4cG9ydCBjb25zdCBlbnZUb0RvbWFpbjogUmVjb3JkPHN0cmluZywgc3RyaW5nPiA9IHtcbiAgRVUxOiAnaHR0cHM6Ly9uZy1hcGktZ3JwYy5jb3JhbG9naXguY29tOjQ0MycsIC8vIGV1LXdlc3QtMSAoSXJlbGFuZClcbiAgRVUyOiAnaHR0cHM6Ly9uZy1hcGktZ3JwYy5ldTIuY29yYWxvZ2l4LmNvbTo0NDMnLCAvLyBldS1ub3J0aC0xIChTdG9ja2hvbG0pXG4gIFVTMTogJ2h0dHBzOi8vbmctYXBpLWdycGMuY29yYWxvZ2l4LnVzOjQ0MycsIC8vIHVzLWVhc3QtMiAoT2hpbylcbiAgVVMyOiAnaHR0cHM6Ly9uZy1hcGktZ3JwYy5jeDQ5OC5jb3JhbG9naXguY29tOjQ0MycsIC8vIHVzLXdlc3QtMiAoT3JlZ29uKVxuICBBUDE6ICdodHRwczovL25nLWFwaS1ncnBjLmFwcC5jb3JhbG9naXguaW46NDQzJywgLy8gYXAtc291dGgtMSAoTXVtYmFpKVxuICBBUDI6ICdodHRwczovL25nLWFwaS1ncnBjLmNvcmFsb2dpeHNnLmNvbTo0NDMnLCAvLyBhcC1zb3V0aGVhc3QtMSAoU2luZ2Fwb3JlKVxuICBBUDM6ICdodHRwczovL25nLWFwaS1ncnBjLmFwMy5jb3JhbG9naXguY29tOjQ0MycsIC8vIGFwLXNvdXRoZWFzdC0zIChKYWthcnRhKVxuICBTVEc6ICdodHRwczovL25nLWFwaS1ncnBjLmFwcC5zdGFnaW5nLmNvcmFsb2dpeC5uZXQ6NDQzJyxcbn07XG4iXX0=