qase-javascript-commons 2.4.0-beta.1 → 2.4.1

package/README.md

@@ -54,10 +54,13 @@ All configuration options are listed in the table below:
 | Qase test run description                                                                                             | `testops.run.description`  | `QASE_TESTOPS_RUN_DESCRIPTION`  | `<Framework name> automated run`        | No       | Any string                 |
 | Qase test run complete                                                                                                | `testops.run.complete`     | `QASE_TESTOPS_RUN_COMPLETE`     | `True`                                  |          | `True`, `False`            |
 | Array of tags to be added to the test run                                                                             | `testops.run.tags`         | `QASE_TESTOPS_RUN_TAGS`         | `[]`                                    | No       | Array of strings           |
+| External link to associate with test run (e.g., Jira ticket)                                                          | `testops.run.externalLink` | `QASE_TESTOPS_RUN_EXTERNAL_LINK` | undefined                              | No       | JSON object with `type` (`jiraCloud` or `jiraServer`) and `link` (e.g., `PROJ-123`) |
 | Qase test plan ID                                                                                                     | `testops.plan.id`          | `QASE_TESTOPS_PLAN_ID`          |  undefined                              | No       | Any integer                |
 | Size of batch for sending test results                                                                                | `testops.batch.size`       | `QASE_TESTOPS_BATCH_SIZE`       | `200`                                   | No       | Any integer                |
 | Enable defects for failed test cases                                                                                  | `testops.defect`           | `QASE_TESTOPS_DEFECT`           | `False`                                 | No       | `True`, `False`            |
 | Enable/disable attachment uploads                                                                                     | `testops.uploadAttachments`        | `QASE_TESTOPS_UPLOAD_ATTACHMENTS`       | `true`                                  | No       | `True`, `False`            |
+| Configuration values to create/find in groups (format: `group1=value1,group2=value2`)                                | `testops.configurations.values`     | `QASE_TESTOPS_CONFIGURATIONS_VALUES`     | undefined                               | No       | Comma-separated key=value pairs |
+| Create configuration groups if they don't exist                                                                       | `testops.configurations.createIfNotExists` | `QASE_TESTOPS_CONFIGURATIONS_CREATE_IF_NOT_EXISTS` | `false`                          | No       | `True`, `False`            |
 
 ### Example `qase.config.json` config:
 
@@ -86,13 +89,40 @@ All configuration options are listed in the table below:
       "title": "Regress run",
       "description": "Regress run description",
       "complete": true,
-      "tags": ["tag1", "tag2"]
+      "tags": ["tag1", "tag2"],
+      "externalLink": {
+        "type": "jiraCloud",
+        "link": "PROJ-123"
+      }
     },
     "defect": false,
     "project": "<project_code>",
     "batch": {
       "size": 100
+    },
+    "configurations": {
+      "values": [
+        {
+          "name": "group1",
+          "value": "value1"
+        },
+        {
+          "name": "group2", 
+          "value": "value2"
+        }
+      ],
+      "createIfNotExists": true
     }
   }
 }
 ```
+
+### Environment Variables Example:
+
+```bash
+# Set external link for Jira Cloud
+export QASE_TESTOPS_RUN_EXTERNAL_LINK='{"type":"jiraCloud","link":"PROJ-123"}'
+
+# Set external link for Jira Server
+export QASE_TESTOPS_RUN_EXTERNAL_LINK='{"type":"jiraServer","link":"PROJ-456"}'
+```

package/changelog.md

@@ -1,3 +1,15 @@
+# qase-javascript-commons@2.4.1
+
+## What's new
+
+Added support for external links in the test run.
+
+# qase-javascript-commons@2.3.6
+
+## What's new
+
+Added support for configurations in the test run.
+
 # qase-javascript-commons@2.3.5
 
 ## What's new

package/dist/client/clientV1.d.ts

@@ -11,6 +11,7 @@ export declare class ClientV1 implements IClient {
     private readonly runClient;
     private readonly environmentClient;
     private readonly attachmentClient;
+    private readonly configurationClient;
     constructor(logger: LoggerInterface, config: TestOpsOptionsType, environment: string | undefined);
     private createApiConfig;
     uploadResults(_runId: number, _results: TestResultType[]): Promise<void>;
@@ -21,6 +22,33 @@ export declare class ClientV1 implements IClient {
     private prepareAttachmentData;
     private getEnvironmentId;
     private prepareRunObject;
+    /**
+     * Get all configuration groups with their configurations
+     * @returns Promise<ConfigurationGroup[]> Array of configuration groups
+     * @private
+     */
+    private getConfigurations;
+    /**
+     * Create a configuration group
+     * @param title Group title
+     * @returns Promise<number | undefined> Created group ID
+     * @private
+     */
+    private createConfigurationGroup;
+    /**
+     * Create a configuration in a group
+     * @param title Configuration title
+     * @param groupId Group ID
+     * @returns Promise<number | undefined> Created configuration ID
+     * @private
+     */
+    private createConfiguration;
+    /**
+     * Handle configuration creation based on config settings
+     * @returns Promise<number[]> Array of configuration IDs
+     * @private
+     */
+    private handleConfigurations;
     /**
      * Process error and throw QaseError
      * @param {Error | AxiosError} error

package/dist/client/clientV1.js

@@ -31,6 +31,7 @@ class ClientV1 {
     runClient;
     environmentClient;
     attachmentClient;
+    configurationClient;
     constructor(logger, config, environment) {
         this.logger = logger;
         this.config = config;
@@ -40,6 +41,7 @@ class ClientV1 {
         this.runClient = new qase_api_client_1.RunsApi(apiConfig);
         this.environmentClient = new qase_api_client_1.EnvironmentsApi(apiConfig);
         this.attachmentClient = new qase_api_client_1.AttachmentsApi(apiConfig);
+        this.configurationClient = new qase_api_client_1.ConfigurationsApi(apiConfig);
     }
     createApiConfig() {
         const apiConfig = new qase_api_client_1.Configuration({ apiKey: this.config.api.token, formDataCtor: form_data_1.default });
@@ -59,14 +61,35 @@ class ClientV1 {
             return this.config.run.id;
         }
         try {
+            // Handle configurations if provided
+            let configurationIds = [];
+            if (this.config.configurations) {
+                configurationIds = await this.handleConfigurations();
+            }
             const environmentId = await this.getEnvironmentId();
-            const runObject = this.prepareRunObject(environmentId);
+            const runObject = this.prepareRunObject(environmentId, configurationIds);
             this.logger.logDebug(`Creating test run: ${JSON.stringify(runObject)}`);
             const { data } = await this.runClient.createRun(this.config.project, runObject);
             if (!data.result?.id) {
                 throw new qase_error_1.QaseError('Failed to create test run');
             }
             this.logger.logDebug(`Test run created: ${JSON.stringify(data)}`);
+            if (this.config.run.externalLink && data.result.id) {
+                // Map our enum values to API enum values
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
+                const apiType = this.config.run.externalLink.type === 'jiraCloud'
+                    ? qase_api_client_1.RunexternalIssuesTypeEnum.CLOUD
+                    : qase_api_client_1.RunexternalIssuesTypeEnum.SERVER;
+                await this.runClient.runUpdateExternalIssue(this.config.project, {
+                    type: apiType,
+                    links: [
+                        {
+                            run_id: data.result.id,
+                            external_issue: this.config.run.externalLink.link,
+                        },
+                    ],
+                });
+            }
             return data.result.id;
         }
         catch (error) {
@@ -139,7 +162,7 @@ class ClientV1 {
         const { data } = await this.environmentClient.getEnvironments(this.config.project, undefined, this.environment, 100);
         return data.result?.entities?.find((env) => env.slug === this.environment)?.id;
     }
-    prepareRunObject(environmentId) {
+    prepareRunObject(environmentId, configurationIds) {
         const runObject = {
             title: this.config.run.title ?? `Automated run ${new Date().toISOString()}`,
             description: this.config.run.description ?? '',
@@ -154,8 +177,137 @@ class ClientV1 {
         if (this.config.plan.id) {
             runObject.plan_id = this.config.plan.id;
         }
+        if (configurationIds && configurationIds.length > 0) {
+            runObject.configurations = configurationIds;
+        }
         return runObject;
     }
+    /**
+     * Get all configuration groups with their configurations
+     * @returns Promise<ConfigurationGroup[]> Array of configuration groups
+     * @private
+     */
+    async getConfigurations() {
+        try {
+            const { data } = await this.configurationClient.getConfigurations(this.config.project);
+            const entities = data.result?.entities ?? [];
+            // Convert API response to domain model
+            return entities.map(group => ({
+                id: group.id ?? 0,
+                title: group.title ?? '',
+                configurations: group.configurations?.map(config => ({
+                    id: config.id ?? 0,
+                    title: config.title ?? ''
+                })) ?? []
+            }));
+        }
+        catch (error) {
+            throw this.processError(error, 'Error getting configurations');
+        }
+    }
+    /**
+     * Create a configuration group
+     * @param title Group title
+     * @returns Promise<number | undefined> Created group ID
+     * @private
+     */
+    async createConfigurationGroup(title) {
+        try {
+            const group = { title };
+            const { data } = await this.configurationClient.createConfigurationGroup(this.config.project, group);
+            return data.result?.id;
+        }
+        catch (error) {
+            throw this.processError(error, 'Error creating configuration group');
+        }
+    }
+    /**
+     * Create a configuration in a group
+     * @param title Configuration title
+     * @param groupId Group ID
+     * @returns Promise<number | undefined> Created configuration ID
+     * @private
+     */
+    async createConfiguration(title, groupId) {
+        try {
+            const config = { title, group_id: groupId };
+            const { data } = await this.configurationClient.createConfiguration(this.config.project, config);
+            return data.result?.id;
+        }
+        catch (error) {
+            throw this.processError(error, 'Error creating configuration');
+        }
+    }
+    /**
+     * Handle configuration creation based on config settings
+     * @returns Promise<number[]> Array of configuration IDs
+     * @private
+     */
+    async handleConfigurations() {
+        if (!this.config.configurations?.values.length) {
+            return [];
+        }
+        const configurationIds = [];
+        try {
+            // Get existing configuration groups
+            const existingGroups = await this.getConfigurations();
+            for (const configValue of this.config.configurations.values) {
+                const { name: groupName, value: configName } = configValue;
+                // Find existing group or create new one
+                const group = existingGroups.find(g => g.title === groupName);
+                let groupId;
+                if (group) {
+                    groupId = group.id;
+                    this.logger.logDebug(`Found existing configuration group: ${groupName}`);
+                }
+                else {
+                    if (this.config.configurations.createIfNotExists) {
+                        const newGroupId = await this.createConfigurationGroup(groupName);
+                        if (newGroupId) {
+                            groupId = newGroupId;
+                            this.logger.logDebug(`Created new configuration group: ${groupName} with ID: ${groupId}`);
+                        }
+                        else {
+                            this.logger.logDebug(`Failed to create configuration group: ${groupName}, skipping`);
+                            continue;
+                        }
+                    }
+                    else {
+                        this.logger.logDebug(`Configuration group not found: ${groupName}, skipping`);
+                        continue;
+                    }
+                }
+                if (groupId) {
+                    // Check if configuration already exists in the group
+                    const existingConfig = group?.configurations.find(c => c.title === configName);
+                    if (!existingConfig) {
+                        // Check if we should create configuration if it doesn't exist
+                        if (this.config.configurations.createIfNotExists) {
+                            const configId = await this.createConfiguration(configName, groupId);
+                            if (configId) {
+                                configurationIds.push(configId);
+                            }
+                            this.logger.logDebug(`Created configuration: ${configName} in group: ${groupName}`);
+                        }
+                        else {
+                            this.logger.logDebug(`Configuration not found: ${configName} in group: ${groupName}, skipping`);
+                        }
+                    }
+                    else {
+                        if (existingConfig.id) {
+                            configurationIds.push(existingConfig.id);
+                        }
+                        this.logger.logDebug(`Configuration already exists: ${configName} in group: ${groupName}`);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            this.logger.logError('Error handling configurations:', error);
+            // Don't throw error to avoid blocking test run creation
+        }
+        return configurationIds;
+    }
     /**
      * Process error and throw QaseError
      * @param {Error | AxiosError} error

package/dist/config/config-validation-schema.d.ts

@@ -1,6 +1,192 @@
-import { JSONSchemaType } from 'ajv';
-import { ConfigType } from './config-type';
+import { ModeEnum } from '../options';
+import { DriverEnum, FormatEnum } from '../writer';
+import { ExternalLinkType } from '../models/config/TestOpsOptionsType';
 /**
  * @type {JSONSchemaType<ConfigType>}
  */
-export declare const configValidationSchema: JSONSchemaType<ConfigType>;
+export declare const configValidationSchema: {
+    type: string;
+    properties: {
+        mode: {
+            type: string;
+            enum: ModeEnum[];
+            nullable: boolean;
+        };
+        fallback: {
+            type: string;
+            enum: ModeEnum[];
+            nullable: boolean;
+        };
+        debug: {
+            type: string;
+            nullable: boolean;
+        };
+        environment: {
+            type: string;
+            nullable: boolean;
+        };
+        captureLogs: {
+            type: string;
+            nullable: boolean;
+        };
+        rootSuite: {
+            type: string;
+            nullable: boolean;
+        };
+        testops: {
+            type: string;
+            nullable: boolean;
+            properties: {
+                api: {
+                    type: string;
+                    nullable: boolean;
+                    properties: {
+                        token: {
+                            type: string;
+                            nullable: boolean;
+                        };
+                        host: {
+                            type: string;
+                            nullable: boolean;
+                        };
+                    };
+                };
+                project: {
+                    type: string;
+                    nullable: boolean;
+                };
+                uploadAttachments: {
+                    type: string;
+                    nullable: boolean;
+                };
+                run: {
+                    type: string;
+                    nullable: boolean;
+                    properties: {
+                        id: {
+                            type: string;
+                            nullable: boolean;
+                        };
+                        title: {
+                            type: string;
+                            nullable: boolean;
+                        };
+                        description: {
+                            type: string;
+                            nullable: boolean;
+                        };
+                        complete: {
+                            type: string;
+                            nullable: boolean;
+                        };
+                        tags: {
+                            type: string;
+                            items: {
+                                type: string;
+                            };
+                            nullable: boolean;
+                        };
+                        externalLink: {
+                            type: string;
+                            nullable: boolean;
+                            properties: {
+                                type: {
+                                    type: string;
+                                    enum: ExternalLinkType[];
+                                };
+                                link: {
+                                    type: string;
+                                };
+                            };
+                            required: string[];
+                        };
+                    };
+                };
+                plan: {
+                    type: string;
+                    nullable: boolean;
+                    properties: {
+                        id: {
+                            type: string;
+                            nullable: boolean;
+                        };
+                    };
+                };
+                batch: {
+                    type: string;
+                    nullable: boolean;
+                    properties: {
+                        size: {
+                            type: string;
+                            nullable: boolean;
+                        };
+                    };
+                };
+                defect: {
+                    type: string;
+                    nullable: boolean;
+                };
+                configurations: {
+                    type: string;
+                    nullable: boolean;
+                    properties: {
+                        values: {
+                            type: string;
+                            items: {
+                                type: string;
+                                properties: {
+                                    name: {
+                                        type: string;
+                                        nullable: boolean;
+                                    };
+                                    value: {
+                                        type: string;
+                                        nullable: boolean;
+                                    };
+                                };
+                                required: string[];
+                            };
+                        };
+                        createIfNotExists: {
+                            type: string;
+                            nullable: boolean;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+        };
+        report: {
+            type: string;
+            nullable: boolean;
+            properties: {
+                driver: {
+                    type: string;
+                    enum: DriverEnum[];
+                    nullable: boolean;
+                };
+                connections: {
+                    type: string;
+                    nullable: boolean;
+                    properties: {
+                        local: {
+                            type: string;
+                            nullable: boolean;
+                            properties: {
+                                path: {
+                                    type: string;
+                                    nullable: boolean;
+                                };
+                                format: {
+                                    type: string;
+                                    enum: FormatEnum[];
+                                    nullable: boolean;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};

package/dist/config/config-validation-schema.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.configValidationSchema = void 0;
 const options_1 = require("../options");
 const writer_1 = require("../writer");
+const TestOpsOptionsType_1 = require("../models/config/TestOpsOptionsType");
 /**
  * @type {JSONSchemaType<ConfigType>}
  */
@@ -88,6 +89,20 @@ exports.configValidationSchema = {
                             },
                             nullable: true,
                         },
+                        externalLink: {
+                            type: 'object',
+                            nullable: true,
+                            properties: {
+                                type: {
+                                    type: 'string',
+                                    enum: [TestOpsOptionsType_1.ExternalLinkType.JIRA_CLOUD, TestOpsOptionsType_1.ExternalLinkType.JIRA_SERVER],
+                                },
+                                link: {
+                                    type: 'string',
+                                },
+                            },
+                            required: ['type', 'link'],
+                        },
                     },
                 },
                 plan: {
@@ -114,6 +129,34 @@ exports.configValidationSchema = {
                     type: 'boolean',
                     nullable: true,
                 },
+                configurations: {
+                    type: 'object',
+                    nullable: true,
+                    properties: {
+                        values: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    name: {
+                                        type: 'string',
+                                        nullable: true,
+                                    },
+                                    value: {
+                                        type: 'string',
+                                        nullable: true,
+                                    },
+                                },
+                                required: ['name', 'value'],
+                            },
+                        },
+                        createIfNotExists: {
+                            type: 'boolean',
+                            nullable: true,
+                        },
+                    },
+                    required: ['values'],
+                },
             },
         },
         report: {

package/dist/env/env-enum.d.ts

@@ -32,7 +32,8 @@ export declare enum EnvRunEnum {
     title = "QASE_TESTOPS_RUN_TITLE",
     description = "QASE_TESTOPS_RUN_DESCRIPTION",
     complete = "QASE_TESTOPS_RUN_COMPLETE",
-    tags = "QASE_TESTOPS_RUN_TAGS"
+    tags = "QASE_TESTOPS_RUN_TAGS",
+    externalLink = "QASE_TESTOPS_RUN_EXTERNAL_LINK"
 }
 /**
  * @enum {string}
@@ -46,6 +47,13 @@ export declare enum EnvPlanEnum {
 export declare enum EnvBatchEnum {
     size = "QASE_TESTOPS_BATCH_SIZE"
 }
+/**
+ * @enum {string}
+ */
+export declare enum EnvConfigurationsEnum {
+    values = "QASE_TESTOPS_CONFIGURATIONS_VALUES",
+    createIfNotExists = "QASE_TESTOPS_CONFIGURATIONS_CREATE_IF_NOT_EXISTS"
+}
 /**
  * @enum {string}
  */

package/dist/env/env-enum.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnvLocalEnum = exports.EnvBatchEnum = exports.EnvPlanEnum = exports.EnvRunEnum = exports.EnvApiEnum = exports.EnvTestOpsEnum = exports.EnvEnum = void 0;
+exports.EnvLocalEnum = exports.EnvConfigurationsEnum = exports.EnvBatchEnum = exports.EnvPlanEnum = exports.EnvRunEnum = exports.EnvApiEnum = exports.EnvTestOpsEnum = exports.EnvEnum = void 0;
 /**
  * @enum {string}
  */
@@ -40,6 +40,7 @@ var EnvRunEnum;
     EnvRunEnum["description"] = "QASE_TESTOPS_RUN_DESCRIPTION";
     EnvRunEnum["complete"] = "QASE_TESTOPS_RUN_COMPLETE";
     EnvRunEnum["tags"] = "QASE_TESTOPS_RUN_TAGS";
+    EnvRunEnum["externalLink"] = "QASE_TESTOPS_RUN_EXTERNAL_LINK";
 })(EnvRunEnum || (exports.EnvRunEnum = EnvRunEnum = {}));
 /**
  * @enum {string}
@@ -55,6 +56,14 @@ var EnvBatchEnum;
 (function (EnvBatchEnum) {
     EnvBatchEnum["size"] = "QASE_TESTOPS_BATCH_SIZE";
 })(EnvBatchEnum || (exports.EnvBatchEnum = EnvBatchEnum = {}));
+/**
+ * @enum {string}
+ */
+var EnvConfigurationsEnum;
+(function (EnvConfigurationsEnum) {
+    EnvConfigurationsEnum["values"] = "QASE_TESTOPS_CONFIGURATIONS_VALUES";
+    EnvConfigurationsEnum["createIfNotExists"] = "QASE_TESTOPS_CONFIGURATIONS_CREATE_IF_NOT_EXISTS";
+})(EnvConfigurationsEnum || (exports.EnvConfigurationsEnum = EnvConfigurationsEnum = {}));
 /**
  * @enum {string}
  */

package/dist/env/env-to-config.js

@@ -26,6 +26,25 @@ const envToConfig = (env) => ({
             description: env[env_enum_1.EnvRunEnum.description],
             complete: env[env_enum_1.EnvRunEnum.complete],
             tags: env[env_enum_1.EnvRunEnum.tags]?.split(',').map(tag => tag.trim()) ?? [],
+            externalLink: env[env_enum_1.EnvRunEnum.externalLink] ? (() => {
+                try {
+                    const externalLinkValue = env[env_enum_1.EnvRunEnum.externalLink];
+                    if (!externalLinkValue)
+                        return undefined;
+                    const parsed = JSON.parse(externalLinkValue);
+                    // Validate that type is a valid ExternalLinkType value
+                    if (parsed.type !== 'jiraCloud' && parsed.type !== 'jiraServer') {
+                        return undefined;
+                    }
+                    return {
+                        type: parsed.type,
+                        link: parsed.link,
+                    };
+                }
+                catch {
+                    return undefined;
+                }
+            })() : undefined,
         },
         plan: {
             id: env[env_enum_1.EnvPlanEnum.id],
@@ -34,6 +53,13 @@ const envToConfig = (env) => ({
             size: env[env_enum_1.EnvBatchEnum.size],
         },
         defect: env[env_enum_1.EnvTestOpsEnum.defect],
+        configurations: env[env_enum_1.EnvConfigurationsEnum.values] ? {
+            values: env[env_enum_1.EnvConfigurationsEnum.values].split(',').map(item => {
+                const [name, value] = item.split('=');
+                return { name: (name ?? '').trim(), value: value ? value.trim() : '' };
+            }),
+            createIfNotExists: env[env_enum_1.EnvConfigurationsEnum.createIfNotExists],
+        } : undefined,
     },
     report: {
         connections: {

package/dist/env/env-type.d.ts

@@ -1,4 +1,4 @@
-import { EnvEnum, EnvTestOpsEnum, EnvApiEnum, EnvRunEnum, EnvLocalEnum, EnvPlanEnum, EnvBatchEnum } from './env-enum';
+import { EnvEnum, EnvTestOpsEnum, EnvApiEnum, EnvRunEnum, EnvLocalEnum, EnvPlanEnum, EnvBatchEnum, EnvConfigurationsEnum } from './env-enum';
 import { ModeEnum } from '../options';
 import { FormatEnum } from '../writer';
 export interface EnvType {
@@ -18,8 +18,11 @@ export interface EnvType {
     [EnvRunEnum.description]?: string;
     [EnvRunEnum.complete]?: boolean;
     [EnvRunEnum.tags]?: string;
+    [EnvRunEnum.externalLink]?: string;
     [EnvPlanEnum.id]?: number;
     [EnvBatchEnum.size]?: number;
+    [EnvConfigurationsEnum.values]?: string;
+    [EnvConfigurationsEnum.createIfNotExists]?: boolean;
     [EnvLocalEnum.path]?: string;
     [EnvLocalEnum.format]?: `${FormatEnum}`;
 }

package/dist/env/env-validation-schema.js

@@ -76,6 +76,10 @@ exports.envValidationSchema = {
             type: 'string',
             nullable: true,
         },
+        [env_enum_1.EnvRunEnum.externalLink]: {
+            type: 'string',
+            nullable: true,
+        },
         [env_enum_1.EnvPlanEnum.id]: {
             type: 'number',
             nullable: true,
@@ -84,6 +88,14 @@ exports.envValidationSchema = {
             type: 'number',
             nullable: true,
         },
+        [env_enum_1.EnvConfigurationsEnum.values]: {
+            type: 'string',
+            nullable: true,
+        },
+        [env_enum_1.EnvConfigurationsEnum.createIfNotExists]: {
+            type: 'boolean',
+            nullable: true,
+        },
         [env_enum_1.EnvLocalEnum.path]: {
             type: 'string',
             nullable: true,

package/dist/models/config/TestOpsOptionsType.d.ts

@@ -6,6 +6,23 @@ export interface TestOpsOptionsType {
     plan: TestOpsPlanType;
     batch?: TestOpsBatchType;
     defect?: boolean | undefined;
+    configurations?: TestOpsConfigurationType | undefined;
+}
+export interface TestOpsConfigurationType {
+    values: TestOpsConfigurationValueType[];
+    createIfNotExists?: boolean | undefined;
+}
+export interface TestOpsConfigurationValueType {
+    name: string;
+    value: string;
+}
+export declare enum ExternalLinkType {
+    JIRA_CLOUD = "jiraCloud",
+    JIRA_SERVER = "jiraServer"
+}
+export interface TestOpsExternalLinkType {
+    type: ExternalLinkType;
+    link: string;
 }
 export interface TestOpsRunType {
     id?: number | undefined;
@@ -13,6 +30,7 @@ export interface TestOpsRunType {
     description?: string;
     complete?: boolean | undefined;
     tags?: string[] | undefined;
+    externalLink?: TestOpsExternalLinkType | undefined;
 }
 export interface TestOpsPlanType {
     id?: number | undefined;

package/dist/models/config/TestOpsOptionsType.js

@@ -1,2 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalLinkType = void 0;
+var ExternalLinkType;
+(function (ExternalLinkType) {
+    ExternalLinkType["JIRA_CLOUD"] = "jiraCloud";
+    ExternalLinkType["JIRA_SERVER"] = "jiraServer";
+})(ExternalLinkType || (exports.ExternalLinkType = ExternalLinkType = {}));

package/dist/models/configuration.d.ts

@@ -0,0 +1,12 @@
+export interface ConfigurationGroup {
+    id: number;
+    title: string;
+    configurations: ConfigurationItem[];
+}
+export interface ConfigurationItem {
+    id: number;
+    title: string;
+}
+export interface ConfigurationGroupResponse {
+    groups: ConfigurationGroup[];
+}

package/dist/models/configuration.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/index.d.ts

@@ -5,3 +5,5 @@ export { StepStatusEnum } from './step-execution';
 export { Attachment } from './attachment';
 export { Report } from './report';
 export { CompoundError } from './error';
+export { ConfigurationGroup, ConfigurationItem, ConfigurationGroupResponse } from './configuration';
+export { ExternalLinkType, TestOpsOptionsType, TestOpsApiType, TestOpsRunType, TestOpsPlanType, TestOpsBatchType, TestOpsConfigurationType, TestOpsConfigurationValueType, TestOpsExternalLinkType } from './config/TestOpsOptionsType';

package/dist/models/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompoundError = exports.StepStatusEnum = exports.StepType = exports.TestStepType = exports.TestStatusEnum = exports.TestExecution = exports.TestResultType = void 0;
+exports.ExternalLinkType = exports.CompoundError = exports.StepStatusEnum = exports.StepType = exports.TestStepType = exports.TestStatusEnum = exports.TestExecution = exports.TestResultType = void 0;
 var test_result_1 = require("./test-result");
 Object.defineProperty(exports, "TestResultType", { enumerable: true, get: function () { return test_result_1.TestResultType; } });
 var test_execution_1 = require("./test-execution");
@@ -13,3 +13,5 @@ var step_execution_1 = require("./step-execution");
 Object.defineProperty(exports, "StepStatusEnum", { enumerable: true, get: function () { return step_execution_1.StepStatusEnum; } });
 var error_1 = require("./error");
 Object.defineProperty(exports, "CompoundError", { enumerable: true, get: function () { return error_1.CompoundError; } });
+var TestOpsOptionsType_1 = require("./config/TestOpsOptionsType");
+Object.defineProperty(exports, "ExternalLinkType", { enumerable: true, get: function () { return TestOpsOptionsType_1.ExternalLinkType; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qase-javascript-commons",
-  "version": "2.4.0-beta.1",
+  "version": "2.4.1",
   "description": "Qase JS Reporters",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -28,7 +28,7 @@
     "async-mutex": "~0.5.0",
     "chalk": "^4.1.2",
     "env-schema": "^5.2.0",
-    "form-data": "^4.0.0",
+    "form-data": "^4.0.4",
     "lodash.get": "^4.4.2",
     "lodash.merge": "^4.6.2",
     "lodash.mergewith": "^4.6.2",